Support dual source blending in GLES2 renderer

GLES2 has GL_EXT_blend_func_extended extension that enables
dual-source blending, so essentially we can reuse fragment shader
from GLSL3 renderer and do 1 rendering pass instead of 3 for the
text.

Co-authored-by: Kirill Chibisov <contact@kchibisov.com>
Co-authored-by: Christian Duerr <contact@christianduerr.com>

Cargo.lock

@@ -29,6 +29,7 @@ dependencies = [
  "log",
  "notify",
  "objc",
+ "once_cell",
  "parking_lot",
  "png",
  "raw-window-handle",
@@ -1191,9 +1192,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.9.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+checksum = "7709cef83f0c1f58f666e746a08b21e0085f7440fa6a29cc194d68aac97a4225"
 
 [[package]]
 name = "os_str_bytes"

alacritty/Cargo.toml

@@ -34,6 +34,7 @@ libc = "0.2"
 unicode-width = "0.1"
 bitflags = "1"
 dirs = "3.0.1"
+once_cell = "1.12"
 
 [build-dependencies]
 gl_generator = "0.14.0"

alacritty/res/glsl3/text.f.glsl

@@ -1,40 +1,73 @@
+#if defined(GLES2_RENDERER)
+// Require extension for dual source blending to work on GLES2.
+#extension GL_EXT_blend_func_extended: require
+
+#define int_t highp int
+#define float_t highp float
+#define vec3_t mediump vec3
+#define texture texture2D
+
+varying mediump vec2 TexCoords;
+varying mediump vec3 fg;
+varying highp float colored;
+varying mediump vec4 bg;
+
+#define FRAG_COLOR gl_FragColor
+#define ALPHA_MASK gl_SecondaryFragColorEXT
+#else
+
+#define int_t int
+#define float_t float
+#define vec3_t vec3
+
 in vec2 TexCoords;
 flat in vec4 fg;
 flat in vec4 bg;
-uniform int backgroundPass;
 
 layout(location = 0, index = 0) out vec4 color;
 layout(location = 0, index = 1) out vec4 alphaMask;
 
+#define FRAG_COLOR color
+#define ALPHA_MASK alphaMask
+#endif
+
+#define COLORED 1
+
+uniform int_t renderingPass;
 uniform sampler2D mask;
 
-#define COLORED 2
-
 void main() {
-    if (backgroundPass != 0) {
+    if (renderingPass == 0) {
         if (bg.a == 0.0) {
             discard;
         }
 
-        alphaMask = vec4(1.0);
-
+        ALPHA_MASK = vec4(1.0);
         // Premultiply background color by alpha.
-        color = vec4(bg.rgb * bg.a, bg.a);
-    } else if ((int(fg.a) & COLORED) != 0) {
+        FRAG_COLOR = vec4(bg.rgb * bg.a, bg.a);
+        return;
+    }
+
+#if !defined(GLES2_RENDERER)
+    float_t colored = fg.a;
+#endif
+
+    // The wide char information is already stripped, so it's safe to check for equality here.
+    if (int(colored) == COLORED) {
         // Color glyphs, like emojis.
-        vec4 glyphColor = texture(mask, TexCoords);
-        alphaMask = vec4(glyphColor.a);
+        FRAG_COLOR = texture(mask, TexCoords);
+        ALPHA_MASK = vec4(FRAG_COLOR.a);
 
         // Revert alpha premultiplication.
-        if (glyphColor.a != 0) {
-            glyphColor.rgb = vec3(glyphColor.rgb / glyphColor.a);
+        if (FRAG_COLOR.a != 0.0) {
+            FRAG_COLOR.rgb = vec3(FRAG_COLOR.rgb / FRAG_COLOR.a);
         }
 
-        color = vec4(glyphColor.rgb, 1.0);
+        FRAG_COLOR = vec4(FRAG_COLOR.rgb, 1.0);
     } else {
         // Regular text glyphs.
-        vec3 textColor = texture(mask, TexCoords).rgb;
-        alphaMask = vec4(textColor, textColor.r);
-        color = vec4(fg.rgb, 1.0);
+        vec3_t textColor = texture(mask, TexCoords).rgb;
+        ALPHA_MASK = vec4(textColor, textColor.r);
+        FRAG_COLOR = vec4(fg.rgb, 1.0);
     }
 }

alacritty/res/glsl3/text.v.glsl

@@ -23,9 +23,9 @@ flat out vec4 bg;
 uniform vec2 cellDim;
 uniform vec4 projection;
 
-uniform int backgroundPass;
+uniform int renderingPass;
 
-#define WIDE_CHAR 1
+#define WIDE_CHAR 2
 
 void main() {
     vec2 projectionOffset = projection.xy;
@@ -39,12 +39,23 @@ void main() {
     // Position of cell from top-left
     vec2 cellPosition = cellDim * gridCoords;
 
-    if (backgroundPass != 0) {
-        vec2 backgroundDim = cellDim;
-        if ((int(textColor.a) & WIDE_CHAR) != 0) {
+    fg = vec4(textColor.rgb / 255.0, textColor.a);
+    bg = backgroundColor / 255.0;
+
+    float occupiedCells = 1;
+    if ((int(fg.a) >= WIDE_CHAR)) {
         // Update wide char x dimension so it'll cover the following spacer.
-            backgroundDim.x *= 2;
+        occupiedCells = 2;
+
+        // Since we don't perform bitwise operations due to limitations of
+        // the GLES2 renderer,we subtract wide char bits keeping only colored.
+        fg.a = round(fg.a - WIDE_CHAR);
     }
+
+    if (renderingPass == 0) {
+        vec2 backgroundDim = cellDim;
+        backgroundDim.x *= occupiedCells;
+
         vec2 finalPosition = cellPosition + backgroundDim * position;
         gl_Position =
             vec4(projectionOffset + projectionScale * finalPosition, 0.0, 1.0);
@@ -63,7 +74,4 @@ void main() {
         vec2 uvSize = uv.zw;
         TexCoords = uvOffset + position * uvSize;
     }
-
-    bg = backgroundColor / 255.0;
-    fg = vec4(textColor.rgb / 255.0, textColor.a);
 }

alacritty/res/rect.f.glsl

@@ -7,7 +7,6 @@ varying color_t color;
 
 #else
 #define float_t float
-#define int_t int
 #define color_t vec4
 
 out vec4 FragColor;

alacritty/src/renderer/mod.rs

@@ -1,8 +1,10 @@
+use std::collections::HashSet;
 use std::ffi::CStr;
 use std::fmt;
 
 use crossfont::Metrics;
 use log::info;
+use once_cell::sync::OnceCell;
 
 use alacritty_terminal::index::Point;
 use alacritty_terminal::term::cell::Flags;
@@ -218,3 +220,40 @@ impl Renderer {
         }
     }
 }
+
+struct GlExtensions;
+
+impl GlExtensions {
+    /// Check if the given `extension` is supported.
+    ///
+    /// This function will lazyly load OpenGL extensions.
+    fn contains(extension: &str) -> bool {
+        static OPENGL_EXTENSIONS: OnceCell<HashSet<&'static str>> = OnceCell::new();
+
+        OPENGL_EXTENSIONS.get_or_init(Self::load_extensions).contains(extension)
+    }
+
+    /// Load available OpenGL extensions.
+    fn load_extensions() -> HashSet<&'static str> {
+        unsafe {
+            let extensions = gl::GetString(gl::EXTENSIONS);
+
+            if extensions.is_null() {
+                let mut extensions_number = 0;
+                gl::GetIntegerv(gl::NUM_EXTENSIONS, &mut extensions_number);
+
+                (0..extensions_number as gl::types::GLuint)
+                    .flat_map(|i| {
+                        let extension = CStr::from_ptr(gl::GetStringi(gl::EXTENSIONS, i) as *mut _);
+                        extension.to_str()
+                    })
+                    .collect()
+            } else {
+                match CStr::from_ptr(extensions as *mut _).to_str() {
+                    Ok(ext) => ext.split_whitespace().collect(),
+                    Err(_) => HashSet::new(),
+                }
+            }
+        }
+    }
+}

alacritty/src/renderer/text/gles2.rs

@@ -11,11 +11,12 @@ use crate::display::SizeInfo;
 use crate::gl;
 use crate::gl::types::*;
 use crate::renderer::shader::{ShaderProgram, ShaderVersion};
-use crate::renderer::{cstr, Error};
+use crate::renderer::{cstr, Error, GlExtensions};
 
 use super::atlas::{Atlas, ATLAS_SIZE};
 use super::{
-    Glyph, LoadGlyph, LoaderApi, TextRenderApi, TextRenderBatch, TextRenderer, TextShader,
+    glsl3, Glyph, LoadGlyph, LoaderApi, RenderingGlyphFlags, RenderingPass, TextRenderApi,
+    TextRenderBatch, TextRenderer, TextShader,
 };
 
 // Shader source.
@@ -32,13 +33,21 @@ pub struct Gles2Renderer {
     batch: Batch,
     current_atlas: usize,
     active_tex: GLuint,
+    dual_source_blending: bool,
 }
 
 impl Gles2Renderer {
     pub fn new() -> Result<Self, Error> {
         info!("Using OpenGL ES 2.0 renderer");
 
-        let program = TextShaderProgram::new(ShaderVersion::Gles2)?;
+        let dual_source_blending = GlExtensions::contains("GL_EXT_blend_func_extended")
+            || GlExtensions::contains("GL_ARB_blend_func_extended");
+
+        if dual_source_blending {
+            info!("Using dual source blending");
+        }
+
+        let program = TextShaderProgram::new(ShaderVersion::Gles2, dual_source_blending)?;
         let mut vao: GLuint = 0;
         let mut vbo: GLuint = 0;
         let mut ebo: GLuint = 0;
@@ -139,6 +148,7 @@ impl Gles2Renderer {
             batch: Batch::new(),
             current_atlas: 0,
             active_tex: 0,
+            dual_source_blending,
         })
     }
 }
@@ -180,6 +190,7 @@ impl<'a> TextRenderer<'a> for Gles2Renderer {
             atlas: &mut self.atlas,
             current_atlas: &mut self.current_atlas,
             program: &mut self.program,
+            dual_source_blending: self.dual_source_blending,
         });
 
         unsafe {
@@ -205,7 +216,7 @@ impl<'a> TextRenderer<'a> for Gles2Renderer {
 /// Maximum items to be drawn in a batch.
 ///
 /// We use the closest number to `u16::MAX` dividable by 4 (amount of vertices we push for a glyph),
-/// since it's the maximum possible index in `glDrawElements` in gles2.
+/// since it's the maximum possible index in `glDrawElements` in GLES2.
 const BATCH_MAX: usize = (u16::MAX - u16::MAX % 4) as usize;
 
 #[derive(Debug)]
@@ -269,7 +280,12 @@ impl TextRenderBatch for Batch {
         let glyph_x = cell.point.column.0 as i16 * size_info.cell_width() as i16 + glyph.left;
         let glyph_y = (cell.point.line + 1) as i16 * size_info.cell_height() as i16 - glyph.top;
 
-        let colored = if glyph.multicolor { 1 } else { 0 };
+        let colored = if glyph.multicolor {
+            RenderingGlyphFlags::COLORED
+        } else {
+            RenderingGlyphFlags::empty()
+        };
+
         let is_wide = if cell.flags.contains(Flags::WIDE_CHAR) { 2 } else { 1 };
 
         let mut vertex = TextVertex {
@@ -322,6 +338,7 @@ pub struct RenderApi<'a> {
     atlas: &'a mut Vec<Atlas>,
     current_atlas: &'a mut usize,
     program: &'a mut TextShaderProgram,
+    dual_source_blending: bool,
 }
 
 impl<'a> Drop for RenderApi<'a> {
@@ -375,8 +392,12 @@ impl<'a> TextRenderApi<Batch> for RenderApi<'a> {
             gl::BlendFunc(gl::ONE, gl::ZERO);
             gl::DrawElements(gl::TRIANGLES, num_indices, gl::UNSIGNED_SHORT, ptr::null());
 
-            // First text rendering pass.
             self.program.set_rendering_pass(RenderingPass::SubpixelPass1);
+            if self.dual_source_blending {
+                // Text rendering pass.
+                gl::BlendFunc(gl::SRC1_COLOR, gl::ONE_MINUS_SRC1_COLOR);
+            } else {
+                // First text rendering pass.
                 gl::BlendFuncSeparate(gl::ZERO, gl::ONE_MINUS_SRC_COLOR, gl::ZERO, gl::ONE);
                 gl::DrawElements(gl::TRIANGLES, num_indices, gl::UNSIGNED_SHORT, ptr::null());
 
@@ -385,9 +406,11 @@ impl<'a> TextRenderApi<Batch> for RenderApi<'a> {
                 gl::BlendFuncSeparate(gl::ONE_MINUS_DST_ALPHA, gl::ONE, gl::ZERO, gl::ONE);
                 gl::DrawElements(gl::TRIANGLES, num_indices, gl::UNSIGNED_SHORT, ptr::null());
 
-            // Third pass.
+                // Third text rendering pass.
                 self.program.set_rendering_pass(RenderingPass::SubpixelPass3);
                 gl::BlendFuncSeparate(gl::ONE, gl::ONE, gl::ONE, gl::ONE_MINUS_SRC_ALPHA);
+            }
+
             gl::DrawElements(gl::TRIANGLES, num_indices, gl::UNSIGNED_SHORT, ptr::null());
         }
 
@@ -416,7 +439,7 @@ struct TextVertex {
     b: u8,
 
     // Whether the glyph is colored.
-    colored: u8,
+    colored: RenderingGlyphFlags,
 
     // Background color.
     bg_r: u8,
@@ -425,15 +448,6 @@ struct TextVertex {
     bg_a: u8,
 }
 
-// NOTE: These flags must be in sync with their usage in the gles2/text.*.glsl shaders.
-#[repr(u8)]
-enum RenderingPass {
-    Background = 0,
-    SubpixelPass1 = 1,
-    SubpixelPass2 = 2,
-    SubpixelPass3 = 3,
-}
-
 #[derive(Debug)]
 pub struct TextShaderProgram {
     /// Shader program.
@@ -444,8 +458,11 @@ pub struct TextShaderProgram {
 
     /// Rendering pass.
     ///
-    /// The rendering is split into 4 passes. One is used for the background and the rest to
-    /// perform subpixel text rendering according to
+    /// For dual source blending, there are 2 passes; one for background, another for text,
+    /// similar to the GLSL3 renderer.
+    ///
+    /// If GL_EXT_blend_func_extended is not available, the rendering is split into 4 passes.
+    /// One is used for the background and the rest to perform subpixel text rendering according to
     /// https://github.com/servo/webrender/blob/master/webrender/doc/text-rendering.md.
     ///
     /// Rendering is split into three passes.
@@ -453,8 +470,12 @@ pub struct TextShaderProgram {
 }
 
 impl TextShaderProgram {
-    pub fn new(shader_version: ShaderVersion) -> Result<Self, Error> {
-        let program = ShaderProgram::new(shader_version, TEXT_SHADER_V, TEXT_SHADER_F)?;
+    pub fn new(shader_version: ShaderVersion, dual_source_blending: bool) -> Result<Self, Error> {
+        let fragment_shader =
+            if dual_source_blending { &glsl3::TEXT_SHADER_F } else { &TEXT_SHADER_F };
+
+        let program = ShaderProgram::new(shader_version, TEXT_SHADER_V, fragment_shader)?;
+
         Ok(Self {
             u_projection: program.get_uniform_location(cstr!("projection"))?,
             u_rendering_pass: program.get_uniform_location(cstr!("renderingPass"))?,

alacritty/src/renderer/text/glsl3.rs

@@ -15,12 +15,12 @@ use crate::renderer::{cstr, Error};
 
 use super::atlas::{Atlas, ATLAS_SIZE};
 use super::{
-    Glyph, LoadGlyph, LoaderApi, RenderingGlyphFlags, TextRenderApi, TextRenderBatch, TextRenderer,
-    TextShader,
+    Glyph, LoadGlyph, LoaderApi, RenderingGlyphFlags, RenderingPass, TextRenderApi,
+    TextRenderBatch, TextRenderer, TextShader,
 };
 
 // Shader source.
-static TEXT_SHADER_F: &str = include_str!("../../../res/glsl3/text.f.glsl");
+pub static TEXT_SHADER_F: &str = include_str!("../../../res/glsl3/text.f.glsl");
 static TEXT_SHADER_V: &str = include_str!("../../../res/glsl3/text.v.glsl");
 
 /// Maximum items to be drawn in a batch.
@@ -240,7 +240,7 @@ impl<'a> TextRenderApi<Batch> for RenderApi<'a> {
         }
 
         unsafe {
-            self.program.set_background_pass(true);
+            self.program.set_rendering_pass(RenderingPass::Background);
             gl::DrawElementsInstanced(
                 gl::TRIANGLES,
                 6,
@@ -248,7 +248,7 @@ impl<'a> TextRenderApi<Batch> for RenderApi<'a> {
                 ptr::null(),
                 self.batch.len() as GLsizei,
             );
-            self.program.set_background_pass(false);
+            self.program.set_rendering_pass(RenderingPass::SubpixelPass1);
             gl::DrawElementsInstanced(
                 gl::TRIANGLES,
                 6,
@@ -419,8 +419,8 @@ pub struct TextShaderProgram {
 
     /// Background pass flag.
     ///
-    /// Rendering is split into two passes; 1 for backgrounds, and one for text.
-    u_background: GLint,
+    /// Rendering is split into two passes; one for backgrounds, and one for text.
+    u_rendering_pass: GLint,
 }
 
 impl TextShaderProgram {
@@ -429,7 +429,7 @@ impl TextShaderProgram {
         Ok(Self {
             u_projection: program.get_uniform_location(cstr!("projection"))?,
             u_cell_dim: program.get_uniform_location(cstr!("cellDim"))?,
-            u_background: program.get_uniform_location(cstr!("backgroundPass"))?,
+            u_rendering_pass: program.get_uniform_location(cstr!("renderingPass"))?,
             program,
         })
     }
@@ -440,11 +440,14 @@ impl TextShaderProgram {
         }
     }
 
-    fn set_background_pass(&self, background_pass: bool) {
-        let value = if background_pass { 1 } else { 0 };
+    fn set_rendering_pass(&self, rendering_pass: RenderingPass) {
+        let value = match rendering_pass {
+            RenderingPass::Background | RenderingPass::SubpixelPass1 => rendering_pass as i32,
+            _ => unreachable!("provided pass is not supported in GLSL3 renderer"),
+        };
 
         unsafe {
-            gl::Uniform1i(self.u_background, value);
+            gl::Uniform1i(self.u_rendering_pass, value);
         }
     }
 }

alacritty/src/renderer/text/mod.rs

@@ -24,11 +24,27 @@ use glyph_cache::{Glyph, LoadGlyph};
 bitflags! {
     #[repr(C)]
     struct RenderingGlyphFlags: u8 {
-        const WIDE_CHAR = 0b0000_0001;
-        const COLORED   = 0b0000_0010;
+        const COLORED   = 0b0000_0001;
+        const WIDE_CHAR = 0b0000_0010;
     }
 }
 
+/// Rendering passes, for both GLES2 and GLSL3 renderer.
+#[repr(u8)]
+enum RenderingPass {
+    /// Rendering pass used to render background color in text shaders.
+    Background = 0,
+
+    /// The first pass to render text with both GLES2 and GLSL3 renderers.
+    SubpixelPass1 = 1,
+
+    /// The second pass to render text with GLES2 renderer.
+    SubpixelPass2 = 2,
+
+    /// The third pass to render text with GLES2 renderer.
+    SubpixelPass3 = 3,
+}
+
 pub trait TextRenderer<'a> {
     type Shader: TextShader;
     type RenderBatch: TextRenderBatch;