Add subtle gradient effect to background

config/default.focus-config

@@ -346,6 +346,7 @@ background1:                            10191FFF
 background2:                            18262FFF
 background3:                            1A2831FF
 background4:                            21333FFF
+gradient_effect:                        FFFFFF5E
 
 # NOTE: for Jai region_scope colors define background colors for blocks of code that fall into those scopes,
 #       so make sure to override those as well if you change the background.

config/default_macos.focus-config

@@ -329,6 +329,7 @@ background1:                            10191FFF
 background2:                            18262FFF
 background3:                            1A2831FF
 background4:                            21333FFF
+gradient_effect:                        FFFFFF5E
 
 # NOTE: for Jai region_scope colors define background colors for blocks of code that fall into those scopes,
 #       so make sure to override those as well if you change the background.

modules/Simp/backend/gl.jai

@@ -232,6 +232,12 @@ backend_init_shaders :: () {
         s.color_scale_loc        = 1;
         s.alpha_blend = true;
     }
+
+    s = *shader_background;
+    {
+        s.gl_handle   = get_shader_program(SHADER_BACKGROUND);
+        s.alpha_blend = true;
+    }
 }
 
 #scope_file
@@ -455,6 +461,74 @@ void main () {
 GLSL
 
 
+SHADER_BACKGROUND :: #string glsl
+OUT_IN vec4 iterated_color;
+
+#ifdef VERTEX_SHADER
+in vec2 vert_position;
+in vec4 vert_color;
+
+uniform mat4 projection;
+
+void main() {
+    gl_Position = projection * vec4(vert_position, 0.0, 1.0);
+    iterated_color = vert_color;
+}
+#endif // VERTEX_SHADER
+
+#ifdef FRAGMENT_SHADER
+uniform vec2 u_resolution;
+uniform float permutator;
+uniform vec4 gradient_settings;
+uniform vec4 fade_rect;
+
+out vec4 color;
+
+float random (in vec2 _st) {
+    return fract(sin(dot(_st.xy, vec2(12.9898,78.233))) * 43758.5453123);
+}
+
+vec4 random4(vec2 co) {
+    vec4 result;
+    result.x = random(co); co *= 2;
+    result.y = random(co); co *= 2;
+    result.z = random(co); co *= 2;
+    result.w = random(co);
+    return result;
+}
+
+void main () {
+    // This shader is duplicated in SHADER_ROUNDED_RECT, if you change one change the other!
+    float colorfulness = gradient_settings.r;
+    float contrast = gradient_settings.g;
+    float permutator_strength = gradient_settings.b;
+    float effect_strength = gradient_settings.a * gradient_settings.a * gradient_settings.a;
+
+    vec2 uv = gl_FragCoord.xy / u_resolution;
+    float permutator_effect = mix(0.5, (1.0-clamp(permutator, 0.0, 1.0)), permutator_strength);
+    vec4 gradient_color = vec4(uv.x, uv.x * uv.y, uv.x * permutator_effect, 0.0);
+    gradient_color = mix(vec4(0.5, 0.25, 0.25, 0), gradient_color, contrast);
+    float luminosity = 0.21 * gradient_color.r + 0.71 * gradient_color.g + 0.07 * gradient_color.b; // https://www.johndcook.com/blog/2009/08/24/algorithms-convert-color-grayscale/
+    vec4 grayscale = vec4(luminosity, luminosity, luminosity, 0);
+    vec4 effect_color = mix(grayscale, gradient_color, colorfulness);
+    vec4 output_color = mix(iterated_color, effect_color, effect_strength);
+
+    // When color is between two displayable values dither it to avoid banding; round it up or down randomly,
+    // proportionate to which it is nearer to.
+    vec4 remainder = fract(output_color * 255.0);
+    color = output_color - (remainder / 255.0) + (1.0 / 255.0) - (step(remainder, random4(uv)) / 255.0);
+    color.a = iterated_color.a;
+
+    // Below here is *not* duplicated into SHADER_ROUNDED_RECT
+    if (fade_rect.z != 0) {
+        float rx = (gl_FragCoord.x - fade_rect.x) / fade_rect.z;
+        color.a *= (1.0 - rx);
+    }
+}
+#endif // FRAGMENT_SHADER
+glsl
+
+
 // @Cleanup:
 // shader_sprite is 1-v from shader_text. Do we pack the text texture upside down,
 // or what?
@@ -520,16 +594,57 @@ void main() {
 #endif // VERTEX_SHADER
 
 #ifdef FRAGMENT_SHADER
+uniform vec2 u_resolution;
+uniform int is_background;
+uniform float permutator;
+uniform vec4 gradient_settings;
+
 out vec4 color;
 
 float rounded_rect_sdf(vec2 frag_pos, vec2 rect_center, vec2 size, float radius) {
     return length(max(abs(frag_pos - rect_center) - size + radius, 0.0)) - radius;
 }
 
+float random (in vec2 _st) {
+    return fract(sin(dot(_st.xy, vec2(12.9898,78.233))) * 43758.5453123);
+}
+
+vec4 random4(vec2 co) {
+    vec4 result;
+    result.x = random(co); co *= 2;
+    result.y = random(co); co *= 2;
+    result.z = random(co); co *= 2;
+    result.w = random(co);
+    return result;
+}
+
 void main () {
     float distance = rounded_rect_sdf(gl_FragCoord.xy, rect_center, rect_size, rect_corner_radius);
-    float smoothed_alpha = 1.0f - smoothstep(0.0f, rect_edge_softness, distance);
-    color = vec4(iterated_color.xyz, iterated_color.a * smoothed_alpha);
+    float smoothed_alpha = 1.0 - smoothstep(0.0, rect_edge_softness, distance);
+    if (is_background != 0) {
+        // This block is duplicated with SHADER_BACKGROUND, if you change one change the other!
+        float colorfulness = gradient_settings.r;
+        float contrast = gradient_settings.g;
+        float permutator_strength = gradient_settings.b;
+        float effect_strength = gradient_settings.a * gradient_settings.a * gradient_settings.a;
+
+        vec2 uv = gl_FragCoord.xy / u_resolution;
+        float permutator_effect = mix(0.5, (1.0-clamp(permutator, 0.0, 1.0)), permutator_strength);
+        vec4 gradient_color = vec4(uv.x, uv.x * uv.y, uv.x * permutator_effect, 0.0);
+        gradient_color = mix(vec4(0.5, 0.25, 0.25, 0), gradient_color, contrast);
+        float luminosity = 0.21 * gradient_color.r + 0.71 * gradient_color.g + 0.07 * gradient_color.b; // https://www.johndcook.com/blog/2009/08/24/algorithms-convert-color-grayscale/
+        vec4 grayscale = vec4(luminosity, luminosity, luminosity, 0);
+        vec4 effect_color = mix(grayscale, gradient_color, colorfulness);
+        vec4 output_color = mix(iterated_color, effect_color, effect_strength);
+
+        // When color is between two displayable values dither it to avoid banding; round it up or down randomly,
+        // proportionate to which it is nearer to.
+        vec4 remainder = fract(output_color * 255.0);
+        color = output_color - (remainder / 255.0) + (1.0 / 255.0) - (step(remainder, random4(uv)) / 255.0);
+    } else {
+        color.xyz = iterated_color.xyz;
+    }
+    color.a = iterated_color.a * smoothed_alpha;
 }
 
 #endif // FRAGMENT_SHADER

modules/Simp/shader.jai

@@ -42,15 +42,28 @@ set_shader_for_images :: (texture: *Texture) {
     immediate_set_texture(texture);
 }
 
-set_shader_for_rects :: () {
+set_shader_for_rects :: (is_background := false, background_permutator := 0.0, background_gradient_settings := Vector4.{}) {
     CheckInit();
     if state.current_shader != *shader_rounded_rect {
         immediate_set_shader(*shader_rounded_rect);
         set_projection();
     }
+    if is_background {
+        c := *context.simp.current_window_info;
+        loc := get_uniform_location(shader_rounded_rect.gl_handle, "u_resolution");
+        glUniform2f(loc, cast(float) c.window_width, cast(float) c.window_height);
+        loc = get_uniform_location(shader_rounded_rect.gl_handle, "permutator");
+        glUniform1f(loc, background_permutator);
+        loc = get_uniform_location(shader_rounded_rect.gl_handle, "gradient_settings");
+        glUniform4f(loc, background_gradient_settings.x, background_gradient_settings.y, background_gradient_settings.z, background_gradient_settings.w);
+        loc = get_uniform_location(shader_rounded_rect.gl_handle, "is_background");
+        glUniform1i(loc, 1);
+    } else {
+        loc := get_uniform_location(shader_rounded_rect.gl_handle, "is_background");
+        glUniform1i(loc, 0);
+    }
 }
 
-
 set_shader_for_gradient :: (rect: Vector4, mode: u8, value: float) {
     CheckInit();
     immediate_set_shader(*shader_gradient);
@@ -63,10 +76,26 @@ set_shader_for_gradient :: (rect: Vector4, mode: u8, value: float) {
     glUniform1f(loc, value);
 }
 
+set_shader_for_background :: (permutator: float, background_gradient_settings: Vector4, rect_for_fade_right := Vector4.{}) {
+    CheckInit();
+    immediate_set_shader(*shader_background);
+    set_projection();
+    c := *context.simp.current_window_info;
+    loc := get_uniform_location(shader_background.gl_handle, "u_resolution");
+    glUniform2f(loc, cast(float) c.window_width, cast(float) c.window_height);
+    loc = get_uniform_location(shader_background.gl_handle, "permutator");
+    glUniform1f(loc, permutator);
+    loc = get_uniform_location(shader_background.gl_handle, "gradient_settings");
+    glUniform4f(loc, background_gradient_settings.x, background_gradient_settings.y, background_gradient_settings.z, background_gradient_settings.w);
+    loc = get_uniform_location(shader_background.gl_handle, "fade_rect");
+    glUniform4f(loc, rect_for_fade_right.x, rect_for_fade_right.y, rect_for_fade_right.z, rect_for_fade_right.w);
+}
+
 
 shader_sprite: Shader;
 shader_text:   Shader;
 shader_color:  Shader;
 shader_color_with_blend:  Shader;
 shader_rounded_rect:      Shader;
 shader_gradient: Shader;
+shader_background: Shader;

src/colors.jai

@@ -11,6 +11,7 @@ Color :: enum u8 {
     BACKGROUND_2;
     BACKGROUND_3;
     BACKGROUND_4;
+    GRADIENT_EFFECT;
     SELECTION_ACTIVE;
     SELECTION_INACTIVE;
     SELECTION_HIGHLIGHT;

src/config_parser.jai

@@ -185,6 +185,7 @@ map_name_to_color :: (name: string) -> Color {
         case "background2";                             return .BACKGROUND_2;
         case "background3";                             return .BACKGROUND_3;
         case "background4";                             return .BACKGROUND_4;
+        case "gradient_effect";                         return .GRADIENT_EFFECT;
         case "selection_active";                        return .SELECTION_ACTIVE;
         case "selection_inactive";                      return .SELECTION_INACTIVE;
         case "selection_highlight";                     return .SELECTION_HIGHLIGHT;