Sinsa/Dotfiles
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

up su Gitea

Browse Source
This commit is contained in:
Sinsa-me
2026-04-19 17:07:18 +02:00
parent e78ce720bb
commit fe54b28378
298 changed files with 23460 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cava/config
+291
View File
@@ -0,0 +1,291 @@
# ┳┳┓┏┓┏┳┓┳┳┏┓┏┓┳┓ ┏┓┏┓┓┏┏┓
# ┃┃┃┣┫ ┃ ┃┃┃┓┣ ┃┃━━┃ ┣┫┃┃┣┫
# ┛ ┗┛┗ ┻ ┗┛┗┛┗┛┛┗ ┗┛┛┗┗┛┛┗
#
## Configuration file for CAVA.
# Remove the ; to change parameters.
[general]
# Smoothing mode. Can be 'normal', 'scientific' or 'waves'. DEPRECATED as of 0.6.0
; mode = normal
# Accepts only non-negative values.
; framerate = 60
# 'autosens' will attempt to decrease sensitivity if the bars peak. 1 = on, 0 = off
# new as of 0.6.0 autosens of low values (dynamic range)
# 'overshoot' allows bars to overshoot (in % of terminal height) without initiating autosens. DEPRECATED as of 0.6.0
; autosens = 1
; overshoot = 20
# Manual sensitivity in %. If autosens is enabled, this will only be the initial value.
# 200 means double height. Accepts only non-negative values.
; sensitivity = 100
# The number of bars (0-512). 0 sets it to auto (fill up console).
# Bars' width and space between bars in number of characters.
; bars = 0
; bar_width = 2
; bar_spacing = 1
# bar_height is only used for output in "noritake" format
; bar_height = 32
# For SDL width and space between bars is in pixels, defaults are:
; bar_width = 20
; bar_spacing = 5
# sdl_glsl have these default values, they are only used to calulate max number of bars.
; bar_width = 1
; bar_spacing = 0
# Lower and higher cutoff frequencies for lowest and highest bars
# the bandwidth of the visualizer.
# Note: there is a minimum total bandwidth of 43Mhz x number of bars.
# Cava will automatically increase the higher cutoff if a too low band is specified.
; lower_cutoff_freq = 50
; higher_cutoff_freq = 10000
# Seconds with no input before cava goes to sleep mode. Cava will not perform FFT or drawing and
# only check for input once per second. Cava will wake up once input is detected. 0 = disable.
; sleep_timer = 0
[input]
# Audio capturing method. Possible methods are: 'fifo', 'portaudio', 'pipewire', 'alsa', 'pulse', 'sndio', 'oss', 'jack' or 'shmem'
# Defaults to 'oss', 'pipewire', 'sndio', 'jack', 'pulse', 'alsa', 'portaudio' or 'fifo', in that order, dependent on what support cava was built with.
# On Mac it defaults to 'portaudio' or 'fifo'
# On windows this is automatic and no input settings are needed.
#
# All input methods uses the same config variable 'source'
# to define where it should get the audio.
#
# For pulseaudio and pipewire 'source' will be the source. Default: 'auto', which uses the monitor source of the default sink
# (all pulseaudio sinks(outputs) have 'monitor' sources(inputs) associated with them).
#
# For pipewire 'source' will be the object name or object.serial of the device to capture from.
# Both input and output devices are supported.
#
# For alsa 'source' will be the capture device.
# For fifo 'source' will be the path to fifo-file.
# For shmem 'source' will be /squeezelite-AA:BB:CC:DD:EE:FF where 'AA:BB:CC:DD:EE:FF' will be squeezelite's MAC address
#
# For sndio 'source' will be a raw recording audio descriptor or a monitoring sub-device, e.g. 'rsnd/2' or 'snd/1'. Default: 'default'.
# README.md contains further information on how to setup CAVA for sndio.
#
# For oss 'source' will be the path to a audio device, e.g. '/dev/dsp2'. Default: '/dev/dsp', i.e. the default audio device.
# README.md contains further information on how to setup CAVA for OSS on FreeBSD.
#
# For jack 'source' will be the name of the JACK server to connect to, e.g. 'foobar'. Default: 'default'.
# README.md contains further information on how to setup CAVA for JACK.
#
method = pulse
source = auto
method = pipewire
source = auto
; method = alsa
; source = hw:Loopback,1
; method = fifo
; source = /tmp/mpd.fifo
; method = shmem
; source = /squeezelite-AA:BB:CC:DD:EE:FF
; method = portaudio
; source = auto
; method = sndio
; source = default
; method = oss
; source = /dev/dsp
; method = jack
; source = default
# The options 'sample_rate', 'sample_bits', 'channels' and 'autoconnect' can be configured for some input methods:
# sample_rate: fifo, pipewire, sndio, oss
# sample_bits: fifo, pipewire, sndio, oss
# channels: sndio, oss, jack
# autoconnect: jack
# Other methods ignore these settings.
#
# For 'sndio' and 'oss' they are only preferred values, i.e. if the values are not supported
# by the chosen audio device, the device will use other supported values instead.
# Example: 48000, 32 and 2, but the device only supports 44100, 16 and 1, then it
# will use 44100, 16 and 1.
#
; sample_rate = 44100
; sample_bits = 16
; channels = 2
; autoconnect = 2
[output]
# Output method. Can be 'ncurses', 'noncurses', 'raw', 'noritake', 'sdl'
# or 'sdl_glsl'.
# 'noncurses' (default) uses a buffer and cursor movements to only print
# changes from frame to frame in the terminal. Uses less resources and is less
# prone to tearing (vsync issues) than 'ncurses'.
#
# 'raw' is an 8 or 16 bit (configurable via the 'bit_format' option) data
# stream of the bar heights that can be used to send to other applications.
# 'raw' defaults to 200 bars, which can be adjusted in the 'bars' option above.
#
# 'noritake' outputs a bitmap in the format expected by a Noritake VFD display
# in graphic mode. It only support the 3000 series graphical VFDs for now.
#
# 'sdl' uses the Simple DirectMedia Layer to render in a graphical context.
# 'sdl_glsl' uses SDL to create an OpenGL context. Write your own shaders or
# use one of the predefined ones.
; method = noncurses
# Orientation of the visualization. Can be 'bottom', 'top', 'left' or 'right'.
# Default is 'bottom'. Other orientations are only supported on sdl and ncruses
# output. Note: many fonts have weird glyphs for 'top' and 'right' characters,
# which can make ncurses not look right.
; orientation = bottom
# Visual channels. Can be 'stereo' or 'mono'.
# 'stereo' mirrors both channels with low frequencies in center.
# 'mono' outputs left to right lowest to highest frequencies.
# 'mono_option' set mono to either take input from 'left', 'right' or 'average'.
# set 'reverse' to 1 to display frequencies the other way around.
; channels = stereo
; mono_option = average
; reverse = 0
# Raw output target. A fifo will be created if target does not exist.
; raw_target = /dev/stdout
# Raw data format. Can be 'binary' or 'ascii'.
; data_format = binary
# Binary bit format, can be '8bit' (0-255) or '16bit' (0-65530).
; bit_format = 16bit
# Ascii max value. In 'ascii' mode range will run from 0 to value specified here
; ascii_max_range = 1000
# Ascii delimiters. In ascii format each bar and frame is separated by a delimiters.
# Use decimal value in ascii table (i.e. 59 = ';' and 10 = '\n' (line feed)).
; bar_delimiter = 59
; frame_delimiter = 10
# sdl window size and position. -1,-1 is centered.
; sdl_width = 1000
; sdl_height = 500
; sdl_x = -1
; sdl_y= -1
; sdl_full_screen = 0
# set label on bars on the x-axis. Can be 'frequency' or 'none'. Default: 'none'
# 'frequency' displays the lower cut off frequency of the bar above.
# Only supported on ncurses and noncurses output.
; xaxis = none
# enable alacritty synchronized updates. 1 = on, 0 = off
# removes flickering in alacritty terminal emulator.
# defaults to off since the behaviour in other terminal emulators is unknown
; alacritty_sync = 0
# Shaders for sdl_glsl, located in $HOME/.config/cava/shaders
; vertex_shader = pass_through.vert
; fragment_shader = bar_spectrum.frag
; for glsl output mode, keep rendering even if no audio
; continuous_rendering = 0
# disable console blank (screen saver) in tty
# (Not supported on FreeBSD)
; disable_blanking = 0
# show a flat bar at the bottom of the screen when idle, 1 = on, 0 = off
; show_idle_bar_heads = 1
# show waveform instead of frequency spectrum, 1 = on, 0 = off
; waveform = 0
[color]
# Colors can be one of seven predefined: black, blue, cyan, green, magenta, red, white, yellow.
# Or defined by hex code '#xxxxxx' (hex code must be within ''). User defined colors requires
# a terminal that can change color definitions such as Gnome-terminal or rxvt.
# default is to keep current terminal color
; background = default
; foreground = default
# SDL and sdl_glsl only support hex code colors, these are the default:
; background = '#111111'
; foreground = '#33ffff'
# these are default
# Gradient mode, only hex defined colors are supported,
# background must also be defined in hex or remain commented out. 1 = on, 0 = off.
# You can define as many as 8 different colors. They range from bottom to top of screen
; gradient = 0
; gradient_count = 8
; gradient_color_1 = '#59cc33'
; gradient_color_2 = '#80cc33'
; gradient_color_3 = '#a6cc33'
; gradient_color_4 = '#cccc33'
; gradient_color_5 = '#cca633'
; gradient_color_6 = '#cc8033'
; gradient_color_7 = '#cc5933'
; gradient_color_8 = '#cc3333'
# for matugen
gradient = 1
gradient_count = 2
gradient_color_1 = '#3b383e'
gradient_color_2 = '#d4bbfc'
[smoothing]
# Percentage value for integral smoothing. Takes values from 0 - 100.
# Higher values means smoother, but less precise. 0 to disable.
# DEPRECATED as of 0.8.0, use noise_reduction instead
; integral = 77
# Disables or enables the so-called "Monstercat smoothing" with or without "waves". Set to 0 to disable.
; monstercat = 0
; waves = 0
# Set gravity percentage for "drop off". Higher values means bars will drop faster.
# Accepts only non-negative values. 50 means half gravity, 200 means double. Set to 0 to disable "drop off".
# DEPRECATED as of 0.8.0, use noise_reduction instead
; gravity = 100
# In bar height, bars that would have been lower that this will not be drawn.
# DEPRECATED as of 0.8.0
; ignore = 0
# Noise reduction, int 0 - 100. default 77
# the raw visualization is very noisy, this factor adjusts the integral and gravity filters to keep the signal smooth
# 100 will be very slow and smooth, 0 will be fast but noisy.
; noise_reduction = 77
[eq]
# This one is tricky. You can have as much keys as you want.
# Remember to uncomment more than one key! More keys = more precision.
# Look at readme.md on github for further explanations and examples.
; 1 = 1 # bass
; 2 = 1
; 3 = 1 # midtone
; 4 = 1
; 5 = 1 # treble
cava/shaders/bar_spectrum.frag
+73
View File
@@ -0,0 +1,73 @@
#version 330
in vec2 fragCoord;
out vec4 fragColor;
// bar values. defaults to left channels first (low to high), then right (high to low).
uniform float bars[512];
uniform int bars_count; // number of bars (left + right) (configurable)
uniform int bar_width; // bar width (configurable), not used here
uniform int bar_spacing; // space between bars (configurable)
uniform vec3 u_resolution; // window resolution
// colors, configurable in cava config file (r,g,b) (0.0 - 1.0)
uniform vec3 bg_color; // background color
uniform vec3 fg_color; // foreground color
uniform int gradient_count;
uniform vec3 gradient_colors[8]; // gradient colors
uniform float shader_time; // shader execution time s (not used here)
uniform sampler2D inputTexture; // Texture from the last render pass (not used here)
vec3 normalize_C(float y, vec3 col_1, vec3 col_2, float y_min, float y_max) {
// create color based on fraction of this color and next color
float yr = (y - y_min) / (y_max - y_min);
return col_1 * (1.0 - yr) + col_2 * yr;
}
void main() {
// find which bar to use based on where we are on the x axis
float x = u_resolution.x * fragCoord.x;
int bar = int(bars_count * fragCoord.x);
// calculate a bar size
float bar_size = u_resolution.x / bars_count;
// the y coordinate and bar values are the same
float y = bars[bar];
// make sure there is a thin line at bottom
if (y * u_resolution.y < 1.0) {
y = 1.0 / u_resolution.y;
}
// draw the bar up to current height
if (y > fragCoord.y) {
// make some space between bars basen on settings
if (x > (bar + 1) * (bar_size)-bar_spacing) {
fragColor = vec4(bg_color, 1.0);
} else {
if (gradient_count == 0) {
fragColor = vec4(fg_color, 1.0);
} else {
// find which color in the configured gradient we are at
int color = int((gradient_count - 1) * fragCoord.y);
// find where on y this and next color is supposed to be
float y_min = color / (gradient_count - 1.0);
float y_max = (color + 1.0) / (gradient_count - 1.0);
// make color
fragColor = vec4(normalize_C(fragCoord.y, gradient_colors[color],
gradient_colors[color + 1], y_min, y_max),
1.0);
}
}
} else {
fragColor = vec4(bg_color, 1.0);
}
}
cava/shaders/eye_of_phi.frag
+117
View File
@@ -0,0 +1,117 @@
#version 330
// this shader was stolen from shadertoy user ChunderFPV
#define SCALE 8.0
#define PI radians(180.0)
#define TAU (PI * 2.0)
#define CS(a) vec2(cos(a), sin(a))
#define PT(u, r) smoothstep(0.0, r, r - length(u))
in vec2 fragCoord;
out vec4 fragColor;
uniform float bars[512];
uniform int bars_count; // number of bars (left + right) (configurable)
uniform float shader_time; // shader execution time s
uniform int bar_width; // bar width (configurable), not used here
uniform int bar_spacing; // space between bars (configurable)
uniform vec3 u_resolution; // window resolution
// colors, configurable in cava config file (r,g,b) (0.0 - 1.0)
uniform vec3 bg_color; // background color
uniform vec3 fg_color; // foreground color
uniform int gradient_count;
uniform vec3 gradient_colors[8]; // gradient colors
// gradient map ( color, equation, time, width, shadow, reciprocal )
vec3 gm(vec3 c, float n, float t, float w, float d, bool i) {
float g = min(abs(n), 1.0 / abs(n));
float s = abs(sin(n * PI - t));
if (i)
s = min(s, abs(sin(PI / n + t)));
return (1.0 - pow(abs(s), w)) * c * pow(g, d) * 6.0;
}
// denominator spiral, use 1/n for numerator
// ( screen xy, spiral exponent, decimal, line width, hardness, rotation )
float ds(vec2 u, float e, float n, float w, float h, float ro) {
float ur = length(u); // unit radius
float sr = pow(ur, e); // spiral radius
float a = round(sr) * n * TAU; // arc
vec2 xy = CS(a + ro) * ur; // xy coords
float l = PT(u - xy, w); // line
float s = mod(sr + 0.5, 1.0); // gradient smooth
s = min(s, 1.0 - s); // darken filter
return l * s * h;
}
void main() {
float t = shader_time / PI * 2.0;
vec4 m = vec4(0, 0, 0, 0); // iMouse;
m.xy = m.xy * 2.0 / u_resolution.xy - 1.0; // ±1x, ±1y
if (m.z > 0.0)
t += m.y * SCALE; // move time with mouse y
float z = (m.z > 0.0) ? pow(1.0 - abs(m.y), sign(m.y)) : 1.0; // zoom (+)
float e = (m.z > 0.0) ? pow(1.0 - abs(m.x), -sign(m.x))
: 1.0; // screen exponent (+)
float se = (m.z > 0.0) ? e * -sign(m.y) : 1.0; // spiral exponent
vec3 bg = vec3(0); // black background
float aa = 3.0; // anti-aliasing
for (float j = 0.0; j < aa; j++)
for (float k = 0.0; k < aa; k++) {
vec3 c = vec3(0);
vec2 o = vec2(j, k) / aa;
vec2 uv = (fragCoord * u_resolution.xy - 0.5 * u_resolution.xy + o) /
u_resolution.y * SCALE * z; // apply cartesian, scale and zoom
if (m.z > 0.0)
uv =
exp(log(abs(uv)) * e) * sign(uv); // warp screen space with exponent
float px = length(fwidth(uv)); // pixel width
float x = uv.x; // every pixel on x
float y = uv.y; // every pixel on y
float l = length(uv); // hypot of xy: sqrt(x*x+y*y)
float mc = (x * x + y * y - 1.0) / y; // metallic circle at xy
float g = min(abs(mc), 1.0 / abs(mc)); // gradient
vec3 gold = vec3(1.0, 0.6, 0.0) * g * l;
vec3 blue = vec3(0.3, 0.5, 0.9) * (1.0 - g);
vec3 rgb = max(gold, blue);
float w = 0.1; // line width
float d = 0.4; // shadow depth
c = max(c, gm(rgb, mc, -t, w * bars[0], d, false)); // metallic
c = max(c, gm(rgb, abs(y / x) * sign(y), -t, w * bars[1], d,
false)); // tangent
c = max(c, gm(rgb, (x * x) / (y * y) * sign(y), -t, w * bars[2], d,
false)); // sqrt cotangent
c = max(c, gm(rgb, (x * x) + (y * y), t, w * bars[3], d,
true)); // sqrt circles
c += rgb * ds(uv, se, t / TAU, px * 2.0 * bars[4], 2.0, 0.0); // spiral 1a
c += rgb * ds(uv, se, t / TAU, px * 2.0 * bars[5], 2.0, PI); // spiral 1b
c +=
rgb * ds(uv, -se, t / TAU, px * 2.0 * bars[6], 2.0, 0.0); // spiral 2a
c += rgb * ds(uv, -se, t / TAU, px * 2.0 * bars[7], 2.0, PI); // spiral 2b
c = max(c, 0.0); // clear negative color
c += pow(max(1.0 - l, 0.0), 3.0 / z); // center glow
if (m.z > 0.0) // display grid on click
{
vec2 xyg = abs(fract(uv + 0.5) - 0.5) / px; // xy grid
c.gb += 0.2 * (1.0 - min(min(xyg.x, xyg.y), 1.0));
}
bg += c;
}
bg /= aa * aa;
bg *= sqrt(bg) * 1.5;
fragColor = vec4(bg, 1.0);
}
cava/shaders/northern_lights.frag
+34
View File
@@ -0,0 +1,34 @@
#version 330
in vec2 fragCoord;
out vec4 fragColor;
// bar values. defaults to left channels first (low to high), then right (high to low).
uniform float bars[512];
uniform int bars_count; // number of bars (left + right) (configurable)
uniform vec3 u_resolution; // window resolution, not used here
//colors, configurable in cava config file
uniform vec3 bg_color; // background color(r,g,b) (0.0 - 1.0), not used here
uniform vec3 fg_color; // foreground color, not used here
void main()
{
// find which bar to use based on where we are on the x axis
int bar = int(bars_count * fragCoord.x);
float bar_y = 1.0 - abs((fragCoord.y - 0.5)) * 2.0;
float y = (bars[bar]) * bar_y;
float bar_x = (fragCoord.x - float(bar) / float(bars_count)) * bars_count;
float bar_r = 1.0 - abs((bar_x - 0.5)) * 2;
bar_r = bar_r * bar_r * 2;
// set color
fragColor.r = fg_color.x * y * bar_r;
fragColor.g = fg_color.y * y * bar_r;
fragColor.b = fg_color.z * y * bar_r;
}
cava/shaders/orion_circle.frag
+129
View File
@@ -0,0 +1,129 @@
// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2026 rezky_nightky <with.rezky@gmail.com>
// Static Orion (non-rotating)
#version 330
in vec2 fragCoord;
out vec4 fragColor;
uniform float bars[512];
uniform int bars_count;
uniform int bar_width;
uniform int bar_spacing;
uniform vec3 u_resolution;
uniform vec3 bg_color;
uniform vec3 fg_color;
uniform int gradient_count;
uniform vec3 gradient_colors[8];
vec3 normalize_C(float y, vec3 col_1, vec3 col_2, float y_min, float y_max) {
const float EPS = 0.0001;
float yr = (y - y_min) / max(y_max - y_min, EPS);
yr = clamp(yr, 0.0, 1.0);
return col_1 * (1.0 - yr) + col_2 * yr;
}
void main() {
vec2 p = fragCoord - vec2(0.5);
p.x *= u_resolution.x / u_resolution.y;
float base_radius = 0.35;
float max_len = 0.15;
float pad = 2.0 / u_resolution.y;
float min_r = max(base_radius - pad, 0.0);
float max_r = base_radius + max_len + pad;
float r2 = dot(p, p);
if (r2 < min_r * min_r || r2 > max_r * max_r) {
fragColor = vec4(bg_color, 1.0);
return;
}
float r = sqrt(r2);
float theta = atan(p.y, p.x);
float pi = radians(180.0);
float tau = pi * 2.0;
float a = (theta + pi) / tau;
a = fract(a);
int bc = min(bars_count, 512);
if (bc <= 0) {
fragColor = vec4(bg_color, 1.0);
return;
}
float cell = a * float(bc);
int bar = int(floor(cell));
bar = clamp(bar, 0, bc - 1);
int bar_next = bar + 1;
if (bar_next >= bc) {
bar_next = 0;
}
float f = fract(cell);
float fill = float(bar_width) / max(float(bar_width + bar_spacing), 1.0);
float angular = abs(f - 0.5);
float px = max(length(dFdx(p)), length(dFdy(p)));
float df = 0.35 * (float(bc) * px) / (tau * max(r, px));
float gap_half = (1.0 - fill) * 0.5;
float eps = 1.0 / (float(bc) * 2048.0);
float gap_cap = max(gap_half - eps, 0.0);
float df_cap = min(gap_cap, fill * 0.15);
df = min(df, max(df_cap, 1e-6));
float angular_alpha = 1.0 - smoothstep(fill * 0.5 - df, fill * 0.5 + df, angular);
angular_alpha *= step(angular, fill * 0.5 + df);
angular_alpha *= step(0.01, angular_alpha);
float y0 = clamp(bars[bar], 0.0, 1.0);
float y1 = clamp(bars[bar_next], 0.0, 1.0);
float y = mix(y0, y1, f);
float amp = y * (1.0 + 0.8 * (1.0 - y));
float min_len = 1.0 / u_resolution.y;
float max_len_cap = max(max_len - min_len, min_len);
float len = min(max(amp * max_len, min_len), max_len_cap);
float act = smoothstep(0.0, min_len / max_len, amp);
float dr = clamp(px, min_len, 2.0 * min_len);
float inner = smoothstep(base_radius - dr, base_radius + dr, r);
float outer = 1.0 - smoothstep(base_radius + len - dr, base_radius + len + dr, r);
float radial_alpha = inner * outer * act;
float outer_cap = 1.0 - smoothstep(base_radius + max_len - dr, base_radius + max_len + dr, r);
radial_alpha *= outer_cap;
float alpha = angular_alpha * radial_alpha;
alpha *= step(0.0035, alpha);
if (alpha == 0.0) {
fragColor = vec4(bg_color, 1.0);
return;
}
vec3 col;
if (gradient_count == 0) {
col = fg_color;
} else {
if (gradient_count == 1) {
col = gradient_colors[0];
} else {
int color = int(floor((gradient_count - 1) * amp));
color = clamp(color, 0, gradient_count - 2);
float y_min = float(color) / (gradient_count - 1.0);
float y_max = float(color + 1) / (gradient_count - 1.0);
col =
normalize_C(amp, gradient_colors[color], gradient_colors[color + 1], y_min, y_max);
}
}
fragColor = vec4(mix(bg_color, col, alpha), 1.0);
}
cava/shaders/orion_circle_rotate.frag
+145
View File
@@ -0,0 +1,145 @@
// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2026 rezky_nightky <with.rezky@gmail.com>
// Rotate Orion
#version 330
in vec2 fragCoord;
out vec4 fragColor;
uniform float bars[512];
uniform int bars_count;
uniform int bar_width;
uniform int bar_spacing;
uniform vec3 u_resolution;
uniform vec3 bg_color;
uniform vec3 fg_color;
uniform int gradient_count;
uniform vec3 gradient_colors[8];
uniform float shader_time;
vec3 normalize_C(float y, vec3 col_1, vec3 col_2, float y_min, float y_max) {
const float EPS = 0.0001;
float yr = (y - y_min) / max(y_max - y_min, EPS);
yr = clamp(yr, 0.0, 1.0);
return col_1 * (1.0 - yr) + col_2 * yr;
}
void main() {
vec2 p = fragCoord - vec2(0.5);
p.x *= u_resolution.x / u_resolution.y;
float base_radius = 0.35;
float max_len = 0.15;
float pad = 2.0 / u_resolution.y;
float min_r = max(base_radius - pad, 0.0);
float max_r = base_radius + max_len + pad;
float r2 = dot(p, p);
if (r2 < min_r * min_r || r2 > max_r * max_r) {
fragColor = vec4(bg_color, 1.0);
return;
}
float r = sqrt(r2);
float theta = atan(p.y, p.x);
float pi = radians(180.0);
float tau = pi * 2.0;
float a = (theta + pi) / tau;
a = fract(a);
int bc = min(bars_count, 512);
if (bc <= 0) {
fragColor = vec4(bg_color, 1.0);
return;
}
// Note: rotation is achieved by phase-shifting bar sampling, not by rotating geometry.
float rotate_speed = 0.10;
float t = fract(shader_time * 0.1);
float phase = fract(t * (rotate_speed / 0.1));
float sweep_speed = 0.12;
float sweep_pos = fract(t * (sweep_speed / 0.1));
float da = abs(a - sweep_pos);
da = min(da, 1.0 - da);
float sweep = 1.0 - smoothstep(0.0, 0.08 + fwidth(a), da);
float a_sample = fract(a + phase);
float cell = a_sample * float(bc);
int bar = int(floor(cell));
bar = clamp(bar, 0, bc - 1);
int bar_next = bar + 1;
if (bar_next >= bc) {
bar_next = 0;
}
float f = fract(cell);
float fill = float(bar_width) / max(float(bar_width + bar_spacing), 1.0);
float angular = abs(f - 0.5);
float px = max(length(dFdx(p)), length(dFdy(p)));
float df = 0.35 * (float(bc) * px) / (tau * max(r, px));
float gap_half = (1.0 - fill) * 0.5;
float eps = 1.0 / (float(bc) * 2048.0);
float gap_cap = max(gap_half - eps, 0.0);
float df_cap = min(gap_cap, fill * 0.15);
df = min(df, max(df_cap, 1e-6));
float angular_alpha = 1.0 - smoothstep(fill * 0.5 - df, fill * 0.5 + df, angular);
angular_alpha *= step(angular, fill * 0.5 + df);
angular_alpha *= step(0.01, angular_alpha);
float y0 = clamp(bars[bar], 0.0, 1.0);
float y1 = clamp(bars[bar_next], 0.0, 1.0);
float y = mix(y0, y1, f);
float amp = y * (1.0 + 0.8 * (1.0 - y));
float min_len = 1.0 / u_resolution.y;
float max_len_cap = max(max_len - min_len, min_len);
float len = min(max(amp * max_len, min_len), max_len_cap);
float act = smoothstep(0.0, min_len / max_len, amp);
float dr = clamp(px, min_len, 2.0 * min_len);
float inner = smoothstep(base_radius - dr, base_radius + dr, r);
float outer = 1.0 - smoothstep(base_radius + len - dr, base_radius + len + dr, r);
float radial_alpha = inner * outer * act;
float outer_cap = 1.0 - smoothstep(base_radius + max_len - dr, base_radius + max_len + dr, r);
radial_alpha *= outer_cap;
float alpha = angular_alpha * radial_alpha;
alpha *= step(0.0035, alpha);
if (alpha == 0.0) {
fragColor = vec4(bg_color, 1.0);
return;
}
vec3 col;
if (gradient_count == 0) {
col = fg_color;
} else {
if (gradient_count == 1) {
col = gradient_colors[0];
} else {
int color = int(floor((gradient_count - 1) * amp));
color = clamp(color, 0, gradient_count - 2);
float y_min = float(color) / (gradient_count - 1.0);
float y_max = float(color + 1) / (gradient_count - 1.0);
col = normalize_C(amp, gradient_colors[color], gradient_colors[color + 1], y_min, y_max);
}
}
col = min(col * (1.0 + 0.35 * sweep * alpha), vec3(1.0));
fragColor = vec4(mix(bg_color, col, alpha), 1.0);
}
cava/shaders/orion_saturn_core.frag
+153
View File
@@ -0,0 +1,153 @@
// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2026 rezky_nightky <with.rezky@gmail.com>
// Orion Saturn core
#version 330
in vec2 fragCoord;
out vec4 fragColor;
uniform float bars[512];
uniform int bars_count;
uniform int bar_width;
uniform int bar_spacing;
uniform vec3 u_resolution;
uniform vec3 bg_color;
uniform vec3 fg_color;
uniform int gradient_count;
uniform vec3 gradient_colors[8];
vec3 normalize_C(float y, vec3 col_1, vec3 col_2, float y_min, float y_max) {
const float EPS = 0.0001;
float yr = (y - y_min) / max(y_max - y_min, EPS);
yr = clamp(yr, 0.0, 1.0);
return col_1 * (1.0 - yr) + col_2 * yr;
}
vec3 gradient_map(float amp) {
if (gradient_count == 0) {
return fg_color;
}
if (gradient_count == 1) {
return gradient_colors[0];
}
int color = int(floor((gradient_count - 1) * amp));
color = clamp(color, 0, gradient_count - 2);
float y_min = float(color) / (gradient_count - 1.0);
float y_max = float(color + 1) / (gradient_count - 1.0);
return normalize_C(amp, gradient_colors[color], gradient_colors[color + 1], y_min, y_max);
}
void main() {
vec2 p = fragCoord - vec2(0.5);
p.x *= u_resolution.x / u_resolution.y;
float base_radius = 0.35;
float max_len = 0.15;
float pad = 2.0 / u_resolution.y;
float max_r = base_radius + max_len + pad;
float r2 = dot(p, p);
if (r2 > max_r * max_r) {
fragColor = vec4(bg_color, 1.0);
return;
}
int bc = min(bars_count, 512);
if (bc <= 0) {
fragColor = vec4(bg_color, 1.0);
return;
}
float r = sqrt(r2);
float pi = radians(180.0);
float tau = pi * 2.0;
float theta = atan(p.y, p.x);
float a = fract((theta + pi) / tau);
float cell = a * float(bc);
int bar = int(floor(cell));
bar = clamp(bar, 0, bc - 1);
int bar_next = bar + 1;
if (bar_next >= bc) {
bar_next = 0;
}
float f = fract(cell);
float fill = float(bar_width) / max(float(bar_width + bar_spacing), 1.0);
float angular = abs(f - 0.5);
float px_ang = max(length(dFdx(p)), length(dFdy(p)));
float df = 0.35 * (float(bc) * px_ang) / (tau * max(r, px_ang));
float gap_half = (1.0 - fill) * 0.5;
float eps = 1.0 / (float(bc) * 2048.0);
float gap_cap = max(gap_half - eps, 0.0);
float df_cap = min(gap_cap, fill * 0.15);
df = min(df, max(df_cap, 1e-6));
float angular_alpha = 1.0 - smoothstep(fill * 0.5 - df, fill * 0.5 + df, angular);
angular_alpha *= step(angular, fill * 0.5 + df);
angular_alpha *= step(0.01, angular_alpha);
float y0 = clamp(bars[bar], 0.0, 1.0);
float y1 = clamp(bars[bar_next], 0.0, 1.0);
float y = mix(y0, y1, f);
float amp = y * (1.0 + 0.8 * (1.0 - y));
float min_len = 1.0 / u_resolution.y;
float max_len_cap = max(max_len - min_len, min_len);
float len = min(max(amp * max_len, min_len), max_len_cap);
float act = smoothstep(0.0, min_len / max_len, amp);
float dr = clamp(px_ang, min_len, 2.0 * min_len);
float inner = smoothstep(base_radius - dr, base_radius + dr, r);
float outer = 1.0 - smoothstep(base_radius + len - dr, base_radius + len + dr, r);
float radial_alpha = inner * outer * act;
float outer_cap = 1.0 - smoothstep(base_radius + max_len - dr, base_radius + max_len + dr, r);
radial_alpha *= outer_cap;
float ring_alpha = angular_alpha * radial_alpha;
ring_alpha *= step(0.0035, ring_alpha);
float core_energy = 0.0;
int core_samples = 0;
int core_limit = min(bc, 64);
for (int i = 0; i < core_limit; i += 2) {
core_energy += clamp(bars[i], 0.0, 1.0);
core_samples++;
}
core_energy /= max(float(core_samples), 1.0);
float core_amp = core_energy * (1.0 + 0.8 * (1.0 - core_energy));
float core_radius = mix(0.07, 0.25, clamp(core_amp * 1.1, 0.0, 1.0));
float px = 1.0 / u_resolution.y;
float core_edge = max(px * 1.5, 0.003);
float core_act = smoothstep(0.0, 0.04, core_amp);
float core_feather = core_edge + dr;
float core_alpha = 1.0 - smoothstep(core_radius - core_feather, core_radius + core_feather, r);
core_alpha = clamp(core_alpha, 0.0, 1.0) * core_act;
if (ring_alpha == 0.0 && core_alpha == 0.0) {
fragColor = vec4(bg_color, 1.0);
return;
}
vec3 col_core = gradient_map(core_amp);
vec3 col_ring = gradient_map(amp);
vec3 col = mix(bg_color, col_core, core_alpha);
col = mix(col, col_ring, ring_alpha);
fragColor = vec4(col, 1.0);
}
cava/shaders/orion_saturn_subring.frag
+154
View File
@@ -0,0 +1,154 @@
// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2026 rezky_nightky <with.rezky@gmail.com>
// Orion Saturn subring
#version 330
in vec2 fragCoord;
out vec4 fragColor;
uniform float bars[512];
uniform int bars_count;
uniform int bar_width;
uniform int bar_spacing;
uniform vec3 u_resolution;
uniform vec3 bg_color;
uniform vec3 fg_color;
uniform int gradient_count;
uniform vec3 gradient_colors[8];
vec3 normalize_C(float y, vec3 col_1, vec3 col_2, float y_min, float y_max) {
const float EPS = 0.0001;
float yr = (y - y_min) / max(y_max - y_min, EPS);
yr = clamp(yr, 0.0, 1.0);
return col_1 * (1.0 - yr) + col_2 * yr;
}
vec3 gradient_map(float amp) {
if (gradient_count == 0) {
return fg_color;
}
if (gradient_count == 1) {
return gradient_colors[0];
}
int color = int(floor((gradient_count - 1) * amp));
color = clamp(color, 0, gradient_count - 2);
float y_min = float(color) / (gradient_count - 1.0);
float y_max = float(color + 1) / (gradient_count - 1.0);
return normalize_C(amp, gradient_colors[color], gradient_colors[color + 1], y_min, y_max);
}
void main() {
vec2 p = fragCoord - vec2(0.5);
p.x *= u_resolution.x / u_resolution.y;
float base_radius = 0.35;
float max_len = 0.15;
float pad = 2.0 / u_resolution.y;
float max_r = base_radius + max_len + pad;
float r2 = dot(p, p);
if (r2 > max_r * max_r) {
fragColor = vec4(bg_color, 1.0);
return;
}
int bc = min(bars_count, 512);
if (bc <= 0) {
fragColor = vec4(bg_color, 1.0);
return;
}
float r = sqrt(r2);
float pi = radians(180.0);
float tau = pi * 2.0;
float theta = atan(p.y, p.x);
float a = fract((theta + pi) / tau);
float cell = a * float(bc);
int bar = int(floor(cell));
bar = clamp(bar, 0, bc - 1);
int bar_next = bar + 1;
if (bar_next >= bc) {
bar_next = 0;
}
float f = fract(cell);
float fill = float(bar_width) / max(float(bar_width + bar_spacing), 1.0);
float angular = abs(f - 0.5);
float px = max(length(dFdx(p)), length(dFdy(p)));
float df = 0.35 * (float(bc) * px) / (tau * max(r, px));
float gap_half = (1.0 - fill) * 0.5;
float eps = 1.0 / (float(bc) * 2048.0);
float gap_cap = max(gap_half - eps, 0.0);
float df_cap = min(gap_cap, fill * 0.15);
df = min(df, max(df_cap, 1e-6));
float angular_alpha = 1.0 - smoothstep(fill * 0.5 - df, fill * 0.5 + df, angular);
angular_alpha *= step(angular, fill * 0.5 + df);
angular_alpha *= step(0.01, angular_alpha);
float y0 = clamp(bars[bar], 0.0, 1.0);
float y1 = clamp(bars[bar_next], 0.0, 1.0);
float y = mix(y0, y1, f);
float amp = y * (1.0 + 0.8 * (1.0 - y));
float min_len = 1.0 / u_resolution.y;
float max_len_cap = max(max_len - min_len, min_len);
float len = min(max(amp * max_len, min_len), max_len_cap);
float act = smoothstep(0.0, min_len / max_len, amp);
float dr = clamp(px, min_len, 2.0 * min_len);
float inner = smoothstep(base_radius - dr, base_radius + dr, r);
float outer = 1.0 - smoothstep(base_radius + len - dr, base_radius + len + dr, r);
float radial_alpha = inner * outer * act;
float outer_cap = 1.0 - smoothstep(base_radius + max_len - dr, base_radius + max_len + dr, r);
radial_alpha *= outer_cap;
float ring_alpha = angular_alpha * radial_alpha;
ring_alpha *= step(0.0035, ring_alpha);
float core_energy = 0.0;
int core_samples = 0;
int core_limit = min(bc, 64);
for (int i = 0; i < core_limit; i += 4) {
core_energy += clamp(bars[i], 0.0, 1.0);
core_samples++;
}
core_energy /= max(float(core_samples), 1.0);
float core_amp = core_energy * (1.0 + 0.8 * (1.0 - core_energy));
float core_radius = mix(0.05, 0.18, clamp(core_amp * 1.2, 0.0, 1.0));
float core_act = smoothstep(0.0, 0.04, core_amp);
float core_half_thickness = 0.007;
float core = smoothstep(core_radius - core_half_thickness - dr,
core_radius - core_half_thickness + dr, r) -
smoothstep(core_radius + core_half_thickness - dr,
core_radius + core_half_thickness + dr, r);
float core_alpha = clamp(core, 0.0, 1.0) * core_act;
if (ring_alpha == 0.0 && core_alpha == 0.0) {
fragColor = vec4(bg_color, 1.0);
return;
}
vec3 col_ring = gradient_map(amp);
vec3 col_core = gradient_map(core_amp);
vec3 col = mix(bg_color, col_ring, ring_alpha);
col = mix(col, col_core, core_alpha);
fragColor = vec4(col, 1.0);
}
cava/shaders/pass_through.vert
+14
View File
@@ -0,0 +1,14 @@
#version 330
// Input vertex data, different for all executions of this shader.
layout(location = 0) in vec3 vertexPosition_modelspace;
// Output data ; will be interpolated for each fragment.
out vec2 fragCoord;
void main()
{
gl_Position = vec4(vertexPosition_modelspace,1);
fragCoord = (vertexPosition_modelspace.xy+vec2(1,1))/2.0;
}
cava/shaders/spectrogram.frag
+53
View File
@@ -0,0 +1,53 @@
#version 330
in vec2 fragCoord;
out vec4 fragColor;
// bar values. defaults to left channels first (low to high), then right (high
// to low).
uniform float bars[512];
uniform int bars_count; // number of bars (left + right) (configurable)
uniform int bar_width; // bar width (configurable), not used here
uniform int bar_spacing; // space between bars (configurable)
uniform vec3 u_resolution; // window resolution
// colors, configurable in cava config file (r,g,b) (0.0 - 1.0)
uniform vec3 bg_color; // background color
uniform vec3 fg_color; // foreground color
uniform int gradient_count;
uniform vec3 gradient_colors[8]; // gradient colors
uniform sampler2D inputTexture; // Texture from the last render pass
vec3 normalize_C(float y, vec3 col_1, vec3 col_2, float y_min, float y_max) {
// create color based on fraction of this color and next color
float yr = (y - y_min) / (y_max - y_min);
return col_1 * (1.0 - yr) + col_2 * yr;
}
void main() {
// find which bar to use based on where we are on the y axis
int bar = int(bars_count * fragCoord.y);
float y = bars[bar];
float band_size = 1.0 / float(bars_count);
float current_band_min = bar * band_size;
float current_band_max = (bar + 1) * band_size;
int hist_length = 512;
float win_size = 1.0 / hist_length;
if (fragCoord.x > 1.0 - win_size) {
if (fragCoord.y > current_band_min && fragCoord.y < current_band_max) {
fragColor = vec4(fg_color * y, 1.0);
}
} else {
vec2 offsetCoord = fragCoord;
offsetCoord.x += float(win_size);
fragColor = texture(inputTexture, offsetCoord);
}
}
cava/shaders/winamp_line_style_spectrum.frag
+112
View File
@@ -0,0 +1,112 @@
#version 330
// Emulate the "line style" spectrum analyzer from Winamp 2.
// Try this config for a demonstration:
/*
[general]
bar_width = 2
bar_spacing = 0
higher_cutoff_freq = 22000
[output]
method = sdl_glsl
channels = mono
fragment_shader = winamp_line_style_spectrum.frag
[color]
background = '#000000'
gradient = 1
gradient_color_1 = '#319C08'
gradient_color_2 = '#29CE10'
gradient_color_3 = '#BDDE29'
gradient_color_4 = '#DEA518'
gradient_color_5 = '#D66600'
gradient_color_6 = '#CE2910'
[smoothing]
noise_reduction = 10
*/
in vec2 fragCoord;
out vec4 fragColor;
// bar values. defaults to left channels first (low to high), then right (high to low).
uniform float bars[512];
uniform int bars_count; // number of bars (left + right) (configurable)
uniform int bar_width; // bar width (configurable), not used here
uniform int bar_spacing; // space between bars (configurable)
uniform vec3 u_resolution; // window resolution
//colors, configurable in cava config file (r,g,b) (0.0 - 1.0)
uniform vec3 bg_color; // background color
uniform vec3 fg_color; // foreground color
uniform int gradient_count;
uniform vec3 gradient_colors[8]; // gradient colors
vec3 normalize_C(float y,vec3 col_1, vec3 col_2, float y_min, float y_max)
{
//create color based on fraction of this color and next color
float yr = (y - y_min) / (y_max - y_min);
return col_1 * (1.0 - yr) + col_2 * yr;
}
void main()
{
// find which bar to use based on where we are on the x axis
float x = u_resolution.x * fragCoord.x;
int bar = int(bars_count * fragCoord.x);
//calculate a bar size
float bar_size = u_resolution.x / bars_count;
//the y coordinate is stretched by 4X to resemble Winamp
float y = min(bars[bar] * 4.0, 1.0);
// make sure there is a thin line at bottom
if (y * u_resolution.y < 1.0)
{
y = 1.0 / u_resolution.y;
}
vec4 bar_color;
if (gradient_count == 0)
{
bar_color = vec4(fg_color,1.0);
}
else
{
//find color in the configured gradient for the top of the bar
int color = int((gradient_count - 1) * y);
//find where on y this and next color is supposed to be
float y_min = float(color) / (gradient_count - 1.0);
float y_max = float(color + 1) / (gradient_count - 1.0);
//make a solid color for the entire bar
bar_color = vec4(normalize_C(y, gradient_colors[color], gradient_colors[color + 1], y_min, y_max), 1.0);
}
//draw the bar up to current height
if (y > fragCoord.y)
{
//make some space between bars based on settings
if (x > (bar + 1) * (bar_size) - bar_spacing)
{
fragColor = vec4(bg_color,1.0);
}
else
{
fragColor = bar_color;
}
}
else
{
fragColor = vec4(bg_color,1.0);
}
}
cava/themes/solarized_dark
+15
View File
@@ -0,0 +1,15 @@
[color]
background = '#001e26'
foreground = '#708183'
gradient = 1
gradient_color_1 = '#268bd2'
gradient_color_2 = '#6c71c4'
gradient_color_3 = '#cb4b16'
horizontal_gradient = 1
horizontal_gradient_color_1 = '#586e75'
horizontal_gradient_color_2 = '#b58900'
horizontal_gradient_color_3 = '#839496'
blend_direction = 'up'
cava/themes/tricolor
+10
View File
@@ -0,0 +1,10 @@
[color]
horizontal_gradient = 1
horizontal_gradient_color_1 = '#c45161'
horizontal_gradient_color_2 = '#e094a0'
horizontal_gradient_color_3 = '#f2b6c0'
horizontal_gradient_color_4 = '#f2dde1'
horizontal_gradient_color_5 = '#cbc7d8'
horizontal_gradient_color_6 = '#8db7d2'
horizontal_gradient_color_7 = '#5e62a9'
horizontal_gradient_color_8 = '#434279'