Question: getting transparent background in sdl_glsl on Windows

[idzmitry]

Win 11.
method = sdl_glsl
Shader

#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

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 bar value represents the amplitude, normalized between 0 and 1
    float amplitude = bars[bar];

    // ensure a minimum visible height (thin line) at the center if amplitude is too small
    if (amplitude * u_resolution.y < 1.0)
    {
        amplitude = 1.0 / u_resolution.y;
    }

    // shift the coordinate system so 0.5 is the center
    float y_center = 0.5;                     // center of the screen vertically
    float y_distance = abs(fragCoord.y - y_center); // distance from center

    // draw the bar symmetrically from the center up and down
    if (y_distance < amplitude / 2.0) // half amplitude above and below center
    {
        // make some space between bars based on settings
        if (x > (bar + 1) * (bar_size) - bar_spacing)
        {
            fragColor = vec4(bg_color, 1);
        }
        else
        {
            if (gradient_count == 0)
            {
                fragColor = vec4(fg_color, 1);
            }
            else
            {
                // remap y from [0, 1] to gradient space, considering symmetry
                float gradient_y = (fragCoord.y - (y_center - amplitude / 2.0)) / amplitude;
                int color = int((gradient_count - 1) * gradient_y);

                // clamp color index to avoid out-of-bounds access
                color = clamp(color, 0, gradient_count - 2);

                // find where on y this and next color is supposed to be
                float y_min = color / (float(gradient_count) - 1.0);
                float y_max = (color + 1.0) / (float(gradient_count) - 1.0);

                // make color
                fragColor = vec4(normalize_C(gradient_y, gradient_colors[color], gradient_colors[color + 1], y_min, y_max), 1);
            }
        }
    }
    else
    {
        fragColor = vec4(bg_color, 1);
    }
}

It produces output like:

Question: can I set semi-transparent background? Already tried fragColor = vec4(bg_color, 0.5);

[karlstav]

There is no support for transparency in the sdl or sdl_glsl. But i think it can be implemented. I will have a look.