added bar spectrum glsl shader with gradient karlstav#431

Author: karlstav

SHADERS.md

@@ -11,7 +11,7 @@ under [output] set `method` to 'sdl_glsl'
 
 use the config options `vertex_shader` and `fragment_shader` to select file.
 
-look in the `normalized_bars.frag` shader for how the shaders interact with cava.
+look in the `bar_spectrum.frag` shader for how the shaders interact with cava.
 
 the custom shaders will use some of the same config parameters as the other output modes, like number of bars.
 

cava.c

@@ -519,7 +519,9 @@ as of 0.4.0 all options are specified in config file, see in '/home/username/.co
 #ifdef SDL_GLSL
             // output: get sdl window size
             case OUTPUT_SDL_GLSL:
-                init_sdl_glsl_surface(&width, &height, p.color, p.bcolor);
+                init_sdl_glsl_surface(&width, &height, p.color, p.bcolor, p.bar_width,
+                                      p.bar_spacing, p.gradient, p.gradient_count,
+                                      p.gradient_colors);
                 break;
 #endif
             case OUTPUT_NONCURSES:

config.c

@@ -16,7 +16,7 @@
 #include <stdbool.h>
 #include <sys/stat.h>
 
-#define NUMBER_OF_SHADERS 2
+#define NUMBER_OF_SHADERS 3
 
 #ifdef _MSC_VER
 #include "Windows.h"
@@ -30,15 +30,17 @@
 INCTXT(ConfigFile, "example_files/config");
 
 // add your custom shaders to be installed here
+INCTXT(bar_spectrum, "output/shaders/bar_spectrum.frag");
 INCTXT(normalized_barsfrag, "output/shaders/normalized_bars.frag");
 INCTXT(pass_throughvert, "output/shaders/pass_through.vert");
 
 // INCTXT will create a char g<name>Data
 const char *default_shader_data[NUMBER_OF_SHADERS] = {gnormalized_barsfragData,
-                                                      gpass_throughvertData};
+                                                      gpass_throughvertData, gbar_spectrumData};
 #endif // _MSC_VER
 // name of the installed shader file, technically does not have to be the same as in the source
-const char *default_shader_name[NUMBER_OF_SHADERS] = {"normalized_bars.frag", "pass_through.vert"};
+const char *default_shader_name[NUMBER_OF_SHADERS] = {"normalized_bars.frag", "pass_through.vert",
+                                                      "bar_spectrum.frag"};
 
 double smoothDef[5] = {1, 1, 1, 1, 1};
 
@@ -634,10 +636,6 @@ bool load_config(char configPath[PATH_MAX], struct config_params *p, bool colors
         p->bar_width = iniparser_getint(ini, "general:bar_width", 20);
         p->bar_spacing = iniparser_getint(ini, "general:bar_spacing", 5);
     }
-    if (strcmp(outputMethod, "sdl_glsl") == 0) {
-        p->bar_width = iniparser_getint(ini, "general:bar_width", 1);
-        p->bar_spacing = iniparser_getint(ini, "general:bar_spacing", 0);
-    }
 
     p->continuous_rendering = iniparser_getint(ini, "output:continuous_rendering", 0);
 

output/sdl_glsl.c

@@ -140,8 +140,9 @@ void init_sdl_glsl_window(int width, int height, int x, int y, char *const verte
     }
 }
 
-void init_sdl_glsl_surface(int *w, int *h, char *const fg_color_string,
-                           char *const bg_color_string) {
+void init_sdl_glsl_surface(int *w, int *h, char *const fg_color_string, char *const bg_color_string,
+                           int bar_width, int bar_spacing, int gradient, int gradient_count,
+                           char **gradient_color_strings) {
     struct colors color = {0};
 
     GLint uniform_bg_col;
@@ -161,6 +162,31 @@ void init_sdl_glsl_surface(int *w, int *h, char *const fg_color_string,
     SDL_GetWindowSize(glWindow, w, h);
     glUniform3f(uniform_res, (float)*w, (float)*h, 0.0f);
 
+    GLint uniform_bar_width;
+    uniform_bar_width = glGetUniformLocation(shading_program, "bar_width");
+    glUniform1i(uniform_bar_width, bar_width);
+
+    GLint uniform_bar_spacing;
+    uniform_bar_spacing = glGetUniformLocation(shading_program, "bar_spacing");
+    glUniform1i(uniform_bar_spacing, bar_spacing);
+
+    GLint uniform_gradient_count;
+    uniform_gradient_count = glGetUniformLocation(shading_program, "gradient_count");
+    if (gradient == 0)
+        gradient_count = 0;
+    glUniform1i(uniform_gradient_count, gradient_count);
+
+    GLint uniform_gradient_colors;
+    uniform_gradient_colors = glGetUniformLocation(shading_program, "gradient_colors");
+    float gradient_colors[8][3];
+    for (int i = 0; i < gradient_count; i++) {
+        parse_color(gradient_color_strings[i], &color);
+        gradient_colors[i][0] = (float)color.R / 255.0;
+        gradient_colors[i][1] = (float)color.G / 255.0;
+        gradient_colors[i][2] = (float)color.B / 255.0;
+    }
+    glUniform3fv(uniform_gradient_colors, 8, (const GLfloat *)gradient_colors);
+
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glDrawElements(GL_TRIANGLE_FAN, 4, GL_UNSIGNED_INT, NULL);
     SDL_GL_SwapWindow(glWindow);

output/sdl_glsl.h

@@ -3,7 +3,8 @@
 void init_sdl_glsl_window(int width, int height, int x, int y, char *const vertex_shader,
                           char *const fragment_shader);
 void init_sdl_glsl_surface(int *width, int *height, char *const fg_color_string,
-                           char *const bg_color_string);
+                           char *const bg_color_string, int bar_width, int bar_spacing,
+                           int gradient, int gradient_count, char **gradient_color_strings);
 int draw_sdl_glsl(int bars_count, const float bars[], int frame_timer, int re_paint,
                   int continuous_rendering);
 void cleanup_sdl_glsl(void);

output/shaders/bar_spectrum.frag

@@ -0,0 +1,63 @@
+#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 bewteen 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)
+{
+    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);
+    float bar_size = u_resolution.x / bars_count;
+
+
+    float y =  bars[bar];
+    if (y > fragCoord.y)
+    {
+
+        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
+            {
+                int color = int((gradient_count - 1) * fragCoord.y);
+                float y_min = color / (gradient_count - 1.0);
+                float y_max = (color + 1.0) / (gradient_count - 1.0);
+                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);
+    }
+}