Split alacritty into a separate crates

The crate containing the entry point is called alacritty, and the crate
containing everything else is called alacritty_terminal.

1 files changed, 1629 insertions, 0 deletions

diff --git a/alacritty_terminal/src/renderer/mod.rs b/alacritty_terminal/src/renderer/mod.rs
new file mode 100644
index 00000000..82c6c2df
--- /dev/null
+++ b/alacritty_terminal/src/renderer/mod.rs
@@ -0,0 +1,1629 @@
+// Copyright 2016 Joe Wilm, The Alacritty Project Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+use std::collections::HashMap;
+use std::fs::File;
+use std::hash::BuildHasherDefault;
+use std::io::{self, Read};
+use std::mem::size_of;
+use std::path::PathBuf;
+use std::ptr;
+use std::sync::mpsc;
+use std::time::Duration;
+
+use fnv::FnvHasher;
+use font::{self, FontDesc, FontKey, GlyphKey, Rasterize, RasterizedGlyph, Rasterizer};
+use glutin::dpi::PhysicalSize;
+use notify::{watcher, DebouncedEvent, RecursiveMode, Watcher};
+
+use crate::ansi::CursorStyle;
+use crate::config::{self, Config, Delta};
+use crate::gl;
+use crate::gl::types::*;
+use crate::index::{Column, Line};
+use crate::renderer::rects::{Rect, Rects};
+use crate::term::color::Rgb;
+use crate::term::{self, cell, RenderableCell, RenderableCellContent};
+
+pub mod rects;
+
+// Shader paths for live reload
+static TEXT_SHADER_F_PATH: &'static str =
+    concat!(env!("CARGO_MANIFEST_DIR"), "/../res/text.f.glsl");
+static TEXT_SHADER_V_PATH: &'static str =
+    concat!(env!("CARGO_MANIFEST_DIR"), "/../res/text.v.glsl");
+static RECT_SHADER_F_PATH: &'static str =
+    concat!(env!("CARGO_MANIFEST_DIR"), "/../res/rect.f.glsl");
+static RECT_SHADER_V_PATH: &'static str =
+    concat!(env!("CARGO_MANIFEST_DIR"), "/../res/rect.v.glsl");
+
+// Shader source which is used when live-shader-reload feature is disable
+static TEXT_SHADER_F: &'static str =
+    include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../res/text.f.glsl"));
+static TEXT_SHADER_V: &'static str =
+    include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../res/text.v.glsl"));
+static RECT_SHADER_F: &'static str =
+    include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../res/rect.f.glsl"));
+static RECT_SHADER_V: &'static str =
+    include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../res/rect.v.glsl"));
+
+/// `LoadGlyph` allows for copying a rasterized glyph into graphics memory
+pub trait LoadGlyph {
+    /// Load the rasterized glyph into GPU memory
+    fn load_glyph(&mut self, rasterized: &RasterizedGlyph) -> Glyph;
+
+    /// Clear any state accumulated from previous loaded glyphs
+    ///
+    /// This can, for instance, be used to reset the texture Atlas.
+    fn clear(&mut self);
+}
+
+enum Msg {
+    ShaderReload,
+}
+
+#[derive(Debug)]
+pub enum Error {
+    ShaderCreation(ShaderCreationError),
+}
+
+impl ::std::error::Error for Error {
+    fn cause(&self) -> Option<&dyn (::std::error::Error)> {
+        match *self {
+            Error::ShaderCreation(ref err) => Some(err),
+        }
+    }
+
+    fn description(&self) -> &str {
+        match *self {
+            Error::ShaderCreation(ref err) => err.description(),
+        }
+    }
+}
+
+impl ::std::fmt::Display for Error {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        match *self {
+            Error::ShaderCreation(ref err) => {
+                write!(f, "There was an error initializing the shaders: {}", err)
+            },
+        }
+    }
+}
+
+impl From<ShaderCreationError> for Error {
+    fn from(val: ShaderCreationError) -> Error {
+        Error::ShaderCreation(val)
+    }
+}
+
+/// Text drawing program
+///
+/// Uniforms are prefixed with "u", and vertex attributes are prefixed with "a".
+#[derive(Debug)]
+pub struct TextShaderProgram {
+    // Program id
+    id: GLuint,
+
+    /// projection scale and offset uniform
+    u_projection: GLint,
+
+    /// Cell dimensions (pixels)
+    u_cell_dim: GLint,
+
+    /// Background pass flag
+    ///
+    /// Rendering is split into two passes; 1 for backgrounds, and one for text
+    u_background: GLint,
+}
+
+/// Rectangle drawing program
+///
+/// Uniforms are prefixed with "u"
+#[derive(Debug)]
+pub struct RectShaderProgram {
+    // Program id
+    id: GLuint,
+    /// Rectangle color
+    u_color: GLint,
+}
+
+#[derive(Copy, Debug, Clone)]
+pub struct Glyph {
+    tex_id: GLuint,
+    top: f32,
+    left: f32,
+    width: f32,
+    height: f32,
+    uv_bot: f32,
+    uv_left: f32,
+    uv_width: f32,
+    uv_height: f32,
+}
+
+/// Naïve glyph cache
+///
+/// Currently only keyed by `char`, and thus not possible to hold different
+/// representations of the same code point.
+pub struct GlyphCache {
+    /// Cache of buffered glyphs
+    cache: HashMap<GlyphKey, Glyph, BuildHasherDefault<FnvHasher>>,
+
+    /// Cache of buffered cursor glyphs
+    cursor_cache: HashMap<CursorStyle, Glyph, BuildHasherDefault<FnvHasher>>,
+
+    /// Rasterizer for loading new glyphs
+    rasterizer: Rasterizer,
+
+    /// regular font
+    font_key: FontKey,
+
+    /// italic font
+    italic_key: FontKey,
+
+    /// bold font
+    bold_key: FontKey,
+
+    /// font size
+    font_size: font::Size,
+
+    /// glyph offset
+    glyph_offset: Delta<i8>,
+
+    metrics: ::font::Metrics,
+}
+
+impl GlyphCache {
+    pub fn new<L>(
+        mut rasterizer: Rasterizer,
+        font: &config::Font,
+        loader: &mut L,
+    ) -> Result<GlyphCache, font::Error>
+    where
+        L: LoadGlyph,
+    {
+        let (regular, bold, italic) = Self::compute_font_keys(font, &mut rasterizer)?;
+
+        // Need to load at least one glyph for the face before calling metrics.
+        // The glyph requested here ('m' at the time of writing) has no special
+        // meaning.
+        rasterizer.get_glyph(GlyphKey { font_key: regular, c: 'm', size: font.size() })?;
+
+        let metrics = rasterizer.metrics(regular, font.size())?;
+
+        let mut cache = GlyphCache {
+            cache: HashMap::default(),
+            cursor_cache: HashMap::default(),
+            rasterizer,
+            font_size: font.size(),
+            font_key: regular,
+            bold_key: bold,
+            italic_key: italic,
+            glyph_offset: *font.glyph_offset(),
+            metrics,
+        };
+
+        cache.load_glyphs_for_font(regular, loader);
+        cache.load_glyphs_for_font(bold, loader);
+        cache.load_glyphs_for_font(italic, loader);
+
+        Ok(cache)
+    }
+
+    fn load_glyphs_for_font<L: LoadGlyph>(&mut self, font: FontKey, loader: &mut L) {
+        let size = self.font_size;
+        for i in 32u8..=128u8 {
+            self.get(GlyphKey { font_key: font, c: i as char, size }, loader);
+        }
+    }
+
+    /// Computes font keys for (Regular, Bold, Italic)
+    fn compute_font_keys(
+        font: &config::Font,
+        rasterizer: &mut Rasterizer,
+    ) -> Result<(FontKey, FontKey, FontKey), font::Error> {
+        let size = font.size();
+
+        // Load regular font
+        let regular_desc =
+            Self::make_desc(&font.normal(), font::Slant::Normal, font::Weight::Normal);
+
+        let regular = rasterizer.load_font(&regular_desc, size)?;
+
+        // helper to load a description if it is not the regular_desc
+        let mut load_or_regular = |desc: FontDesc| {
+            if desc == regular_desc {
+                regular
+            } else {
+                rasterizer.load_font(&desc, size).unwrap_or_else(|_| regular)
+            }
+        };
+
+        // Load bold font
+        let bold_desc = Self::make_desc(&font.bold(), font::Slant::Normal, font::Weight::Bold);
+
+        let bold = load_or_regular(bold_desc);
+
+        // Load italic font
+        let italic_desc =
+            Self::make_desc(&font.italic(), font::Slant::Italic, font::Weight::Normal);
+
+        let italic = load_or_regular(italic_desc);
+
+        Ok((regular, bold, italic))
+    }
+
+    fn make_desc(
+        desc: &config::FontDescription,
+        slant: font::Slant,
+        weight: font::Weight,
+    ) -> FontDesc {
+        let style = if let Some(ref spec) = desc.style {
+            font::Style::Specific(spec.to_owned())
+        } else {
+            font::Style::Description { slant, weight }
+        };
+        FontDesc::new(desc.family.clone(), style)
+    }
+
+    pub fn font_metrics(&self) -> font::Metrics {
+        self.rasterizer
+            .metrics(self.font_key, self.font_size)
+            .expect("metrics load since font is loaded at glyph cache creation")
+    }
+
+    pub fn get<'a, L>(&'a mut self, glyph_key: GlyphKey, loader: &mut L) -> &'a Glyph
+    where
+        L: LoadGlyph,
+    {
+        let glyph_offset = self.glyph_offset;
+        let rasterizer = &mut self.rasterizer;
+        let metrics = &self.metrics;
+        self.cache.entry(glyph_key).or_insert_with(|| {
+            let mut rasterized =
+                rasterizer.get_glyph(glyph_key).unwrap_or_else(|_| Default::default());
+
+            rasterized.left += i32::from(glyph_offset.x);
+            rasterized.top += i32::from(glyph_offset.y);
+            rasterized.top -= metrics.descent as i32;
+
+            loader.load_glyph(&rasterized)
+        })
+    }
+
+    pub fn update_font_size<L: LoadGlyph>(
+        &mut self,
+        font: &config::Font,
+        size: font::Size,
+        dpr: f64,
+        loader: &mut L,
+    ) -> Result<(), font::Error> {
+        // Clear currently cached data in both GL and the registry
+        loader.clear();
+        self.cache = HashMap::default();
+        self.cursor_cache = HashMap::default();
+
+        // Update dpi scaling
+        self.rasterizer.update_dpr(dpr as f32);
+
+        // Recompute font keys
+        let font = font.to_owned().with_size(size);
+        let (regular, bold, italic) = Self::compute_font_keys(&font, &mut self.rasterizer)?;
+
+        self.rasterizer.get_glyph(GlyphKey { font_key: regular, c: 'm', size: font.size() })?;
+        let metrics = self.rasterizer.metrics(regular, size)?;
+
+        info!("Font size changed to {:?} with DPR of {}", font.size, dpr);
+
+        self.font_size = font.size;
+        self.font_key = regular;
+        self.bold_key = bold;
+        self.italic_key = italic;
+        self.metrics = metrics;
+
+        self.load_glyphs_for_font(regular, loader);
+        self.load_glyphs_for_font(bold, loader);
+        self.load_glyphs_for_font(italic, loader);
+
+        Ok(())
+    }
+
+    // Calculate font metrics without access to a glyph cache
+    //
+    // This should only be used *before* OpenGL is initialized and the glyph cache can be filled.
+    pub fn static_metrics(config: &Config, dpr: f32) -> Result<font::Metrics, font::Error> {
+        let font = config.font().clone();
+
+        let mut rasterizer = font::Rasterizer::new(dpr, config.use_thin_strokes())?;
+        let regular_desc =
+            GlyphCache::make_desc(&font.normal(), font::Slant::Normal, font::Weight::Normal);
+        let regular = rasterizer.load_font(&regular_desc, font.size())?;
+        rasterizer.get_glyph(GlyphKey { font_key: regular, c: 'm', size: font.size() })?;
+
+        rasterizer.metrics(regular, font.size())
+    }
+}
+
+#[derive(Debug)]
+#[repr(C)]
+struct InstanceData {
+    // coords
+    col: f32,
+    row: f32,
+    // glyph offset
+    left: f32,
+    top: f32,
+    // glyph scale
+    width: f32,
+    height: f32,
+    // uv offset
+    uv_left: f32,
+    uv_bot: f32,
+    // uv scale
+    uv_width: f32,
+    uv_height: f32,
+    // color
+    r: f32,
+    g: f32,
+    b: f32,
+    // background color
+    bg_r: f32,
+    bg_g: f32,
+    bg_b: f32,
+    bg_a: f32,
+}
+
+#[derive(Debug)]
+pub struct QuadRenderer {
+    program: TextShaderProgram,
+    rect_program: RectShaderProgram,
+    vao: GLuint,
+    ebo: GLuint,
+    vbo_instance: GLuint,
+    rect_vao: GLuint,
+    rect_vbo: GLuint,
+    atlas: Vec<Atlas>,
+    current_atlas: usize,
+    active_tex: GLuint,
+    batch: Batch,
+    rx: mpsc::Receiver<Msg>,
+}
+
+#[derive(Debug)]
+pub struct RenderApi<'a> {
+    active_tex: &'a mut GLuint,
+    batch: &'a mut Batch,
+    atlas: &'a mut Vec<Atlas>,
+    current_atlas: &'a mut usize,
+    program: &'a mut TextShaderProgram,
+    config: &'a Config,
+}
+
+#[derive(Debug)]
+pub struct LoaderApi<'a> {
+    active_tex: &'a mut GLuint,
+    atlas: &'a mut Vec<Atlas>,
+    current_atlas: &'a mut usize,
+}
+
+#[derive(Debug)]
+pub struct PackedVertex {
+    x: f32,
+    y: f32,
+}
+
+#[derive(Debug, Default)]
+pub struct Batch {
+    tex: GLuint,
+    instances: Vec<InstanceData>,
+}
+
+impl Batch {
+    #[inline]
+    pub fn new() -> Batch {
+        Batch { tex: 0, instances: Vec::with_capacity(BATCH_MAX) }
+    }
+
+    pub fn add_item(&mut self, cell: &RenderableCell, glyph: &Glyph) {
+        if self.is_empty() {
+            self.tex = glyph.tex_id;
+        }
+
+        self.instances.push(InstanceData {
+            col: cell.column.0 as f32,
+            row: cell.line.0 as f32,
+
+            top: glyph.top,
+            left: glyph.left,
+            width: glyph.width,
+            height: glyph.height,
+
+            uv_bot: glyph.uv_bot,
+            uv_left: glyph.uv_left,
+            uv_width: glyph.uv_width,
+            uv_height: glyph.uv_height,
+
+            r: f32::from(cell.fg.r),
+            g: f32::from(cell.fg.g),
+            b: f32::from(cell.fg.b),
+
+            bg_r: f32::from(cell.bg.r),
+            bg_g: f32::from(cell.bg.g),
+            bg_b: f32::from(cell.bg.b),
+            bg_a: cell.bg_alpha,
+        });
+    }
+
+    #[inline]
+    pub fn full(&self) -> bool {
+        self.capacity() == self.len()
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.instances.len()
+    }
+
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        BATCH_MAX
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    #[inline]
+    pub fn size(&self) -> usize {
+        self.len() * size_of::<InstanceData>()
+    }
+
+    pub fn clear(&mut self) {
+        self.tex = 0;
+        self.instances.clear();
+    }
+}
+
+/// Maximum items to be drawn in a batch.
+const BATCH_MAX: usize = 0x1_0000;
+const ATLAS_SIZE: i32 = 1024;
+
+impl QuadRenderer {
+    pub fn new() -> Result<QuadRenderer, Error> {
+        let program = TextShaderProgram::new()?;
+        let rect_program = RectShaderProgram::new()?;
+
+        let mut vao: GLuint = 0;
+        let mut ebo: GLuint = 0;
+
+        let mut vbo_instance: GLuint = 0;
+
+        let mut rect_vao: GLuint = 0;
+        let mut rect_vbo: GLuint = 0;
+        let mut rect_ebo: GLuint = 0;
+
+        unsafe {
+            gl::Enable(gl::BLEND);
+            gl::BlendFunc(gl::SRC1_COLOR, gl::ONE_MINUS_SRC1_COLOR);
+            gl::Enable(gl::MULTISAMPLE);
+
+            // Disable depth mask, as the renderer never uses depth tests
+            gl::DepthMask(gl::FALSE);
+
+            gl::GenVertexArrays(1, &mut vao);
+            gl::GenBuffers(1, &mut ebo);
+            gl::GenBuffers(1, &mut vbo_instance);
+            gl::BindVertexArray(vao);
+
+            // ---------------------
+            // Set up element buffer
+            // ---------------------
+            let indices: [u32; 6] = [0, 1, 3, 1, 2, 3];
+
+            gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, ebo);
+            gl::BufferData(
+                gl::ELEMENT_ARRAY_BUFFER,
+                (6 * size_of::<u32>()) as isize,
+                indices.as_ptr() as *const _,
+                gl::STATIC_DRAW,
+            );
+
+            // ----------------------------
+            // Setup vertex instance buffer
+            // ----------------------------
+            gl::BindBuffer(gl::ARRAY_BUFFER, vbo_instance);
+            gl::BufferData(
+                gl::ARRAY_BUFFER,
+                (BATCH_MAX * size_of::<InstanceData>()) as isize,
+                ptr::null(),
+                gl::STREAM_DRAW,
+            );
+            // coords
+            gl::VertexAttribPointer(
+                0,
+                2,
+                gl::FLOAT,
+                gl::FALSE,
+                size_of::<InstanceData>() as i32,
+                ptr::null(),
+            );
+            gl::EnableVertexAttribArray(0);
+            gl::VertexAttribDivisor(0, 1);
+            // glyphoffset
+            gl::VertexAttribPointer(
+                1,
+                4,
+                gl::FLOAT,
+                gl::FALSE,
+                size_of::<InstanceData>() as i32,
+                (2 * size_of::<f32>()) as *const _,
+            );
+            gl::EnableVertexAttribArray(1);
+            gl::VertexAttribDivisor(1, 1);
+            // uv
+            gl::VertexAttribPointer(
+                2,
+                4,
+                gl::FLOAT,
+                gl::FALSE,
+                size_of::<InstanceData>() as i32,
+                (6 * size_of::<f32>()) as *const _,
+            );
+            gl::EnableVertexAttribArray(2);
+            gl::VertexAttribDivisor(2, 1);
+            // color
+            gl::VertexAttribPointer(
+                3,
+                3,
+                gl::FLOAT,
+                gl::FALSE,
+                size_of::<InstanceData>() as i32,
+                (10 * size_of::<f32>()) as *const _,
+            );
+            gl::EnableVertexAttribArray(3);
+            gl::VertexAttribDivisor(3, 1);
+            // color
+            gl::VertexAttribPointer(
+                4,
+                4,
+                gl::FLOAT,
+                gl::FALSE,
+                size_of::<InstanceData>() as i32,
+                (13 * size_of::<f32>()) as *const _,
+            );
+            gl::EnableVertexAttribArray(4);
+            gl::VertexAttribDivisor(4, 1);
+
+            // Rectangle setup
+            gl::GenVertexArrays(1, &mut rect_vao);
+            gl::GenBuffers(1, &mut rect_vbo);
+            gl::GenBuffers(1, &mut rect_ebo);
+            gl::BindVertexArray(rect_vao);
+            let indices: [i32; 6] = [0, 1, 3, 1, 2, 3];
+            gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, rect_ebo);
+            gl::BufferData(
+                gl::ELEMENT_ARRAY_BUFFER,
+                (size_of::<i32>() * indices.len()) as _,
+                indices.as_ptr() as *const _,
+                gl::STATIC_DRAW,
+            );
+
+            // Cleanup
+            gl::BindVertexArray(0);
+            gl::BindBuffer(gl::ARRAY_BUFFER, 0);
+            gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, 0);
+        }
+
+        let (msg_tx, msg_rx) = mpsc::channel();
+
+        if cfg!(feature = "live-shader-reload") {
+            ::std::thread::spawn(move || {
+                let (tx, rx) = ::std::sync::mpsc::channel();
+                // The Duration argument is a debouncing period.
+                let mut watcher =
+                    watcher(tx, Duration::from_millis(10)).expect("create file watcher");
+                watcher
+                    .watch(TEXT_SHADER_F_PATH, RecursiveMode::NonRecursive)
+                    .expect("watch fragment shader");
+                watcher
+                    .watch(TEXT_SHADER_V_PATH, RecursiveMode::NonRecursive)
+                    .expect("watch vertex shader");
+
+                loop {
+                    let event = rx.recv().expect("watcher event");
+
+                    match event {
+                        DebouncedEvent::Rename(..) => continue,
+                        DebouncedEvent::Create(_)
+                        | DebouncedEvent::Write(_)
+                        | DebouncedEvent::Chmod(_) => {
+                            msg_tx.send(Msg::ShaderReload).expect("msg send ok");
+                        },
+                        _ => {},
+                    }
+                }
+            });
+        }
+
+        let mut renderer = QuadRenderer {
+            program,
+            rect_program,
+            vao,
+            ebo,
+            vbo_instance,
+            rect_vao,
+            rect_vbo,
+            atlas: Vec::new(),
+            current_atlas: 0,
+            active_tex: 0,
+            batch: Batch::new(),
+            rx: msg_rx,
+        };
+
+        let atlas = Atlas::new(ATLAS_SIZE);
+        renderer.atlas.push(atlas);
+
+        Ok(renderer)
+    }
+
+    // Draw all rectangles simultaneously to prevent excessive program swaps
+    pub fn draw_rects(
+        &mut self,
+        config: &Config,
+        props: &term::SizeInfo,
+        visual_bell_intensity: f64,
+        cell_line_rects: Rects,
+    ) {
+        // Swap to rectangle rendering program
+        unsafe {
+            // Swap program
+            gl::UseProgram(self.rect_program.id);
+
+            // Remove padding from viewport
+            gl::Viewport(0, 0, props.width as i32, props.height as i32);
+
+            // Change blending strategy
+            gl::BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA);
+
+            // Setup data and buffers
+            gl::BindVertexArray(self.rect_vao);
+            gl::BindBuffer(gl::ARRAY_BUFFER, self.rect_vbo);
+
+            // Position
+            gl::VertexAttribPointer(
+                0,
+                2,
+                gl::FLOAT,
+                gl::FALSE,
+                (size_of::<f32>() * 2) as _,
+                ptr::null(),
+            );
+            gl::EnableVertexAttribArray(0);
+        }
+
+        // Draw visual bell
+        let color = config.visual_bell().color();
+        let rect = Rect::new(0., 0., props.width, props.height);
+        self.render_rect(&rect, color, visual_bell_intensity as f32, props);
+
+        // Draw underlines and strikeouts
+        for cell_line_rect in cell_line_rects.rects() {
+            self.render_rect(&cell_line_rect.0, cell_line_rect.1, 255., props);
+        }
+
+        // Deactivate rectangle program again
+        unsafe {
+            // Reset blending strategy
+            gl::BlendFunc(gl::SRC1_COLOR, gl::ONE_MINUS_SRC1_COLOR);
+
+            // Reset data and buffers
+            gl::BindBuffer(gl::ARRAY_BUFFER, 0);
+            gl::BindVertexArray(0);
+
+            let padding_x = props.padding_x as i32;
+            let padding_y = props.padding_y as i32;
+            let width = props.width as i32;
+            let height = props.height as i32;
+            gl::Viewport(padding_x, padding_y, width - 2 * padding_x, height - 2 * padding_y);
+
+            // Disable program
+            gl::UseProgram(0);
+        }
+    }
+
+    pub fn with_api<F, T>(&mut self, config: &Config, props: &term::SizeInfo, func: F) -> T
+    where
+        F: FnOnce(RenderApi<'_>) -> T,
+    {
+        // Flush message queue
+        if let Ok(Msg::ShaderReload) = self.rx.try_recv() {
+            self.reload_shaders(props);
+        }
+        while let Ok(_) = self.rx.try_recv() {}
+
+        unsafe {
+            gl::UseProgram(self.program.id);
+            self.program.set_term_uniforms(props);
+
+            gl::BindVertexArray(self.vao);
+            gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, self.ebo);
+            gl::BindBuffer(gl::ARRAY_BUFFER, self.vbo_instance);
+            gl::ActiveTexture(gl::TEXTURE0);
+        }
+
+        let res = func(RenderApi {
+            active_tex: &mut self.active_tex,
+            batch: &mut self.batch,
+            atlas: &mut self.atlas,
+            current_atlas: &mut self.current_atlas,
+            program: &mut self.program,
+            config,
+        });
+
+        unsafe {
+            gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, 0);
+            gl::BindBuffer(gl::ARRAY_BUFFER, 0);
+            gl::BindVertexArray(0);
+
+            gl::UseProgram(0);
+        }
+
+        res
+    }
+
+    pub fn with_loader<F, T>(&mut self, func: F) -> T
+    where
+        F: FnOnce(LoaderApi<'_>) -> T,
+    {
+        unsafe {
+            gl::ActiveTexture(gl::TEXTURE0);
+        }
+
+        func(LoaderApi {
+            active_tex: &mut self.active_tex,
+            atlas: &mut self.atlas,
+            current_atlas: &mut self.current_atlas,
+        })
+    }
+
+    pub fn reload_shaders(&mut self, props: &term::SizeInfo) {
+        info!("Reloading shaders...");
+        let result = (TextShaderProgram::new(), RectShaderProgram::new());
+        let (program, rect_program) = match result {
+            (Ok(program), Ok(rect_program)) => {
+                unsafe {
+                    gl::UseProgram(program.id);
+                    program.update_projection(
+                        props.width,
+                        props.height,
+                        props.padding_x,
+                        props.padding_y,
+                    );
+                    gl::UseProgram(0);
+                }
+
+                info!("... successfully reloaded shaders");
+                (program, rect_program)
+            },
+            (Err(err), _) | (_, Err(err)) => {
+                error!("{}", err);
+                return;
+            },
+        };
+
+        self.active_tex = 0;
+        self.program = program;
+        self.rect_program = rect_program;
+    }
+
+    pub fn resize(&mut self, size: PhysicalSize, padding_x: f32, padding_y: f32) {
+        let (width, height): (u32, u32) = size.into();
+
+        // viewport
+        unsafe {
+            let width = width as i32;
+            let height = height as i32;
+            let padding_x = padding_x as i32;
+            let padding_y = padding_y as i32;
+            gl::Viewport(padding_x, padding_y, width - 2 * padding_x, height - 2 * padding_y);
+
+            // update projection
+            gl::UseProgram(self.program.id);
+            self.program.update_projection(
+                width as f32,
+                height as f32,
+                padding_x as f32,
+                padding_y as f32,
+            );
+            gl::UseProgram(0);
+        }
+    }
+
+    // Render a rectangle
+    //
+    // This requires the rectangle program to be activated
+    fn render_rect(&mut self, rect: &Rect<f32>, color: Rgb, alpha: f32, size: &term::SizeInfo) {
+        // Do nothing when alpha is fully transparent
+        if alpha == 0. {
+            return;
+        }
+
+        // Calculate rectangle position
+        let center_x = size.width / 2.;
+        let center_y = size.height / 2.;
+        let x = (rect.x - center_x) / center_x;
+        let y = -(rect.y - center_y) / center_y;
+        let width = rect.width / center_x;
+        let height = rect.height / center_y;
+
+        unsafe {
+            // Setup vertices
+            let vertices: [f32; 8] = [x + width, y, x + width, y - height, x, y - height, x, y];
+
+            // Load vertex data into array buffer
+            gl::BufferData(
+                gl::ARRAY_BUFFER,
+                (size_of::<f32>() * vertices.len()) as _,
+                vertices.as_ptr() as *const _,
+                gl::STATIC_DRAW,
+            );
+
+            // Color
+            self.rect_program.set_color(color, alpha);
+
+            // Draw the rectangle
+            gl::DrawElements(gl::TRIANGLES, 6, gl::UNSIGNED_INT, ptr::null());
+        }
+    }
+}
+
+impl<'a> RenderApi<'a> {
+    pub fn clear(&self, color: Rgb) {
+        let alpha = self.config.background_opacity().get();
+        unsafe {
+            gl::ClearColor(
+                (f32::from(color.r) / 255.0).min(1.0) * alpha,
+                (f32::from(color.g) / 255.0).min(1.0) * alpha,
+                (f32::from(color.b) / 255.0).min(1.0) * alpha,
+                alpha,
+            );
+            gl::Clear(gl::COLOR_BUFFER_BIT);
+        }
+    }
+
+    fn render_batch(&mut self) {
+        unsafe {
+            gl::BufferSubData(
+                gl::ARRAY_BUFFER,
+                0,
+                self.batch.size() as isize,
+                self.batch.instances.as_ptr() as *const _,
+            );
+        }
+
+        // Bind texture if necessary
+        if *self.active_tex != self.batch.tex {
+            unsafe {
+                gl::BindTexture(gl::TEXTURE_2D, self.batch.tex);
+            }
+            *self.active_tex = self.batch.tex;
+        }
+
+        unsafe {
+            self.program.set_background_pass(true);
+            gl::DrawElementsInstanced(
+                gl::TRIANGLES,
+                6,
+                gl::UNSIGNED_INT,
+                ptr::null(),
+                self.batch.len() as GLsizei,
+            );
+            self.program.set_background_pass(false);
+            gl::DrawElementsInstanced(
+                gl::TRIANGLES,
+                6,
+                gl::UNSIGNED_INT,
+                ptr::null(),
+                self.batch.len() as GLsizei,
+            );
+        }
+
+        self.batch.clear();
+    }
+
+    /// Render a string in a variable location. Used for printing the render timer, warnings and
+    /// errors.
+    pub fn render_string(
+        &mut self,
+        string: &str,
+        line: Line,
+        glyph_cache: &mut GlyphCache,
+        color: Option<Rgb>,
+    ) {
+        let bg_alpha = color.map(|_| 1.0).unwrap_or(0.0);
+        let col = Column(0);
+
+        let cells = string
+            .chars()
+            .enumerate()
+            .map(|(i, c)| RenderableCell {
+                line,
+                column: col + i,
+                inner: RenderableCellContent::Chars({
+                    let mut chars = [' '; cell::MAX_ZEROWIDTH_CHARS + 1];
+                    chars[0] = c;
+                    chars
+                }),
+                bg: color.unwrap_or(Rgb { r: 0, g: 0, b: 0 }),
+                fg: Rgb { r: 0, g: 0, b: 0 },
+                flags: cell::Flags::empty(),
+                bg_alpha,
+            })
+            .collect::<Vec<_>>();
+
+        for cell in cells {
+            self.render_cell(cell, glyph_cache);
+        }
+    }
+
+    #[inline]
+    fn add_render_item(&mut self, cell: &RenderableCell, glyph: &Glyph) {
+        // Flush batch if tex changing
+        if !self.batch.is_empty() && self.batch.tex != glyph.tex_id {
+            self.render_batch();
+        }
+
+        self.batch.add_item(cell, glyph);
+
+        // Render batch and clear if it's full
+        if self.batch.full() {
+            self.render_batch();
+        }
+    }
+
+    pub fn render_cell(&mut self, cell: RenderableCell, glyph_cache: &mut GlyphCache) {
+        let chars = match cell.inner {
+            RenderableCellContent::Cursor((cursor_style, ref raw)) => {
+                // Raw cell pixel buffers like cursors don't need to go through font lookup
+                let glyph = glyph_cache
+                    .cursor_cache
+                    .entry(cursor_style)
+                    .or_insert_with(|| self.load_glyph(raw));
+                self.add_render_item(&cell, &glyph);
+                return;
+            },
+            RenderableCellContent::Chars(chars) => chars,
+        };
+
+        // Get font key for cell
+        // FIXME this is super inefficient.
+        let font_key = if cell.flags.contains(cell::Flags::BOLD) {
+            glyph_cache.bold_key
+        } else if cell.flags.contains(cell::Flags::ITALIC) {
+            glyph_cache.italic_key
+        } else {
+            glyph_cache.font_key
+        };
+
+        // Don't render text of HIDDEN cells
+        let mut chars = if cell.flags.contains(cell::Flags::HIDDEN) {
+            [' '; cell::MAX_ZEROWIDTH_CHARS + 1]
+        } else {
+            chars
+        };
+
+        // Render tabs as spaces in case the font doesn't support it
+        if chars[0] == '\t' {
+            chars[0] = ' ';
+        }
+
+        let mut glyph_key = GlyphKey { font_key, size: glyph_cache.font_size, c: chars[0] };
+
+        // Add cell to batch
+        let glyph = glyph_cache.get(glyph_key, self);
+        self.add_render_item(&cell, glyph);
+
+        // Render zero-width characters
+        for c in (&chars[1..]).iter().filter(|c| **c != ' ') {
+            glyph_key.c = *c;
+            let mut glyph = *glyph_cache.get(glyph_key, self);
+
+            // The metrics of zero-width characters are based on rendering
+            // the character after the current cell, with the anchor at the
+            // right side of the preceding character. Since we render the
+            // zero-width characters inside the preceding character, the
+            // anchor has been moved to the right by one cell.
+            glyph.left += glyph_cache.metrics.average_advance as f32;
+
+            self.add_render_item(&cell, &glyph);
+        }
+    }
+}
+
+/// Load a glyph into a texture atlas
+///
+/// If the current atlas is full, a new one will be created.
+#[inline]
+fn load_glyph(
+    active_tex: &mut GLuint,
+    atlas: &mut Vec<Atlas>,
+    current_atlas: &mut usize,
+    rasterized: &RasterizedGlyph,
+) -> Glyph {
+    // At least one atlas is guaranteed to be in the `self.atlas` list; thus
+    // the unwrap.
+    match atlas[*current_atlas].insert(rasterized, active_tex) {
+        Ok(glyph) => glyph,
+        Err(AtlasInsertError::Full) => {
+            *current_atlas += 1;
+            if *current_atlas == atlas.len() {
+                let new = Atlas::new(ATLAS_SIZE);
+                *active_tex = 0; // Atlas::new binds a texture. Ugh this is sloppy.
+                atlas.push(new);
+            }
+            load_glyph(active_tex, atlas, current_atlas, rasterized)
+        },
+        Err(AtlasInsertError::GlyphTooLarge) => Glyph {
+            tex_id: atlas[*current_atlas].id,
+            top: 0.0,
+            left: 0.0,
+            width: 0.0,
+            height: 0.0,
+            uv_bot: 0.0,
+            uv_left: 0.0,
+            uv_width: 0.0,
+            uv_height: 0.0,
+        },
+    }
+}
+
+#[inline]
+fn clear_atlas(atlas: &mut Vec<Atlas>, current_atlas: &mut usize) {
+    for atlas in atlas.iter_mut() {
+        atlas.clear();
+    }
+    *current_atlas = 0;
+}
+
+impl<'a> LoadGlyph for LoaderApi<'a> {
+    fn load_glyph(&mut self, rasterized: &RasterizedGlyph) -> Glyph {
+        load_glyph(self.active_tex, self.atlas, self.current_atlas, rasterized)
+    }
+
+    fn clear(&mut self) {
+        clear_atlas(self.atlas, self.current_atlas)
+    }
+}
+
+impl<'a> LoadGlyph for RenderApi<'a> {
+    fn load_glyph(&mut self, rasterized: &RasterizedGlyph) -> Glyph {
+        load_glyph(self.active_tex, self.atlas, self.current_atlas, rasterized)
+    }
+
+    fn clear(&mut self) {
+        clear_atlas(self.atlas, self.current_atlas)
+    }
+}
+
+impl<'a> Drop for RenderApi<'a> {
+    fn drop(&mut self) {
+        if !self.batch.is_empty() {
+            self.render_batch();
+        }
+    }
+}
+
+impl TextShaderProgram {
+    pub fn new() -> Result<TextShaderProgram, ShaderCreationError> {
+        let (vertex_src, fragment_src) = if cfg!(feature = "live-shader-reload") {
+            (None, None)
+        } else {
+            (Some(TEXT_SHADER_V), Some(TEXT_SHADER_F))
+        };
+        let vertex_shader = create_shader(TEXT_SHADER_V_PATH, gl::VERTEX_SHADER, vertex_src)?;
+        let fragment_shader = create_shader(TEXT_SHADER_F_PATH, gl::FRAGMENT_SHADER, fragment_src)?;
+        let program = create_program(vertex_shader, fragment_shader)?;
+
+        unsafe {
+            gl::DeleteShader(fragment_shader);
+            gl::DeleteShader(vertex_shader);
+            gl::UseProgram(program);
+        }
+
+        macro_rules! cptr {
+            ($thing:expr) => {
+                $thing.as_ptr() as *const _
+            };
+        }
+
+        macro_rules! assert_uniform_valid {
+            ($uniform:expr) => {
+                assert!($uniform != gl::INVALID_VALUE as i32);
+                assert!($uniform != gl::INVALID_OPERATION as i32);
+            };
+            ( $( $uniform:expr ),* ) => {
+                $( assert_uniform_valid!($uniform); )*
+            };
+        }
+
+        // get uniform locations
+        let (projection, cell_dim, background) = unsafe {
+            (
+                gl::GetUniformLocation(program, cptr!(b"projection\0")),
+                gl::GetUniformLocation(program, cptr!(b"cellDim\0")),
+                gl::GetUniformLocation(program, cptr!(b"backgroundPass\0")),
+            )
+        };
+
+        assert_uniform_valid!(projection, cell_dim, background);
+
+        let shader = TextShaderProgram {
+            id: program,
+            u_projection: projection,
+            u_cell_dim: cell_dim,
+            u_background: background,
+        };
+
+        unsafe {
+            gl::UseProgram(0);
+        }
+
+        Ok(shader)
+    }
+
+    fn update_projection(&self, width: f32, height: f32, padding_x: f32, padding_y: f32) {
+        // Bounds check
+        if (width as u32) < (2 * padding_x as u32) || (height as u32) < (2 * padding_y as u32) {
+            return;
+        }
+
+        // Compute scale and offset factors, from pixel to ndc space. Y is inverted
+        //   [0, width - 2 * padding_x] to [-1, 1]
+        //   [height - 2 * padding_y, 0] to [-1, 1]
+        let scale_x = 2. / (width - 2. * padding_x);
+        let scale_y = -2. / (height - 2. * padding_y);
+        let offset_x = -1.;
+        let offset_y = 1.;
+
+        info!("Width: {}, Height: {}", width, height);
+
+        unsafe {
+            gl::Uniform4f(self.u_projection, offset_x, offset_y, scale_x, scale_y);
+        }
+    }
+
+    fn set_term_uniforms(&self, props: &term::SizeInfo) {
+        unsafe {
+            gl::Uniform2f(self.u_cell_dim, props.cell_width, props.cell_height);
+        }
+    }
+
+    fn set_background_pass(&self, background_pass: bool) {
+        let value = if background_pass { 1 } else { 0 };
+
+        unsafe {
+            gl::Uniform1i(self.u_background, value);
+        }
+    }
+}
+
+impl Drop for TextShaderProgram {
+    fn drop(&mut self) {
+        unsafe {
+            gl::DeleteProgram(self.id);
+        }
+    }
+}
+
+impl RectShaderProgram {
+    pub fn new() -> Result<Self, ShaderCreationError> {
+        let (vertex_src, fragment_src) = if cfg!(feature = "live-shader-reload") {
+            (None, None)
+        } else {
+            (Some(RECT_SHADER_V), Some(RECT_SHADER_F))
+        };
+        let vertex_shader = create_shader(RECT_SHADER_V_PATH, gl::VERTEX_SHADER, vertex_src)?;
+        let fragment_shader = create_shader(RECT_SHADER_F_PATH, gl::FRAGMENT_SHADER, fragment_src)?;
+        let program = create_program(vertex_shader, fragment_shader)?;
+
+        unsafe {
+            gl::DeleteShader(fragment_shader);
+            gl::DeleteShader(vertex_shader);
+            gl::UseProgram(program);
+        }
+
+        // get uniform locations
+        let u_color = unsafe { gl::GetUniformLocation(program, b"color\0".as_ptr() as *const _) };
+
+        let shader = RectShaderProgram { id: program, u_color };
+
+        unsafe { gl::UseProgram(0) }
+
+        Ok(shader)
+    }
+
+    fn set_color(&self, color: Rgb, alpha: f32) {
+        unsafe {
+            gl::Uniform4f(
+                self.u_color,
+                f32::from(color.r) / 255.,
+                f32::from(color.g) / 255.,
+                f32::from(color.b) / 255.,
+                alpha,
+            );
+        }
+    }
+}
+
+impl Drop for RectShaderProgram {
+    fn drop(&mut self) {
+        unsafe {
+            gl::DeleteProgram(self.id);
+        }
+    }
+}
+
+fn create_program(vertex: GLuint, fragment: GLuint) -> Result<GLuint, ShaderCreationError> {
+    unsafe {
+        let program = gl::CreateProgram();
+        gl::AttachShader(program, vertex);
+        gl::AttachShader(program, fragment);
+        gl::LinkProgram(program);
+
+        let mut success: GLint = 0;
+        gl::GetProgramiv(program, gl::LINK_STATUS, &mut success);
+
+        if success == i32::from(gl::TRUE) {
+            Ok(program)
+        } else {
+            Err(ShaderCreationError::Link(get_program_info_log(program)))
+        }
+    }
+}
+
+fn create_shader(
+    path: &str,
+    kind: GLenum,
+    source: Option<&'static str>,
+) -> Result<GLuint, ShaderCreationError> {
+    let from_disk;
+    let source = if let Some(src) = source {
+        src
+    } else {
+        from_disk = read_file(path)?;
+        &from_disk[..]
+    };
+
+    let len: [GLint; 1] = [source.len() as GLint];
+
+    let shader = unsafe {
+        let shader = gl::CreateShader(kind);
+        gl::ShaderSource(shader, 1, &(source.as_ptr() as *const _), len.as_ptr());
+        gl::CompileShader(shader);
+        shader
+    };
+
+    let mut success: GLint = 0;
+    unsafe {
+        gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut success);
+    }
+
+    if success == GLint::from(gl::TRUE) {
+        Ok(shader)
+    } else {
+        // Read log
+        let log = get_shader_info_log(shader);
+
+        // Cleanup
+        unsafe {
+            gl::DeleteShader(shader);
+        }
+
+        Err(ShaderCreationError::Compile(PathBuf::from(path), log))
+    }
+}
+
+fn get_program_info_log(program: GLuint) -> String {
+    // Get expected log length
+    let mut max_length: GLint = 0;
+    unsafe {
+        gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut max_length);
+    }
+
+    // Read the info log
+    let mut actual_length: GLint = 0;
+    let mut buf: Vec<u8> = Vec::with_capacity(max_length as usize);
+    unsafe {
+        gl::GetProgramInfoLog(program, max_length, &mut actual_length, buf.as_mut_ptr() as *mut _);
+    }
+
+    // Build a string
+    unsafe {
+        buf.set_len(actual_length as usize);
+    }
+
+    // XXX should we expect opengl to return garbage?
+    String::from_utf8(buf).unwrap()
+}
+
+fn get_shader_info_log(shader: GLuint) -> String {
+    // Get expected log length
+    let mut max_length: GLint = 0;
+    unsafe {
+        gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut max_length);
+    }
+
+    // Read the info log
+    let mut actual_length: GLint = 0;
+    let mut buf: Vec<u8> = Vec::with_capacity(max_length as usize);
+    unsafe {
+        gl::GetShaderInfoLog(shader, max_length, &mut actual_length, buf.as_mut_ptr() as *mut _);
+    }
+
+    // Build a string
+    unsafe {
+        buf.set_len(actual_length as usize);
+    }
+
+    // XXX should we expect opengl to return garbage?
+    String::from_utf8(buf).unwrap()
+}
+
+fn read_file(path: &str) -> Result<String, io::Error> {
+    let mut f = File::open(path)?;
+    let mut buf = String::new();
+    f.read_to_string(&mut buf)?;
+
+    Ok(buf)
+}
+
+#[derive(Debug)]
+pub enum ShaderCreationError {
+    /// Error reading file
+    Io(io::Error),
+
+    /// Error compiling shader
+    Compile(PathBuf, String),
+
+    /// Problem linking
+    Link(String),
+}
+
+impl ::std::error::Error for ShaderCreationError {
+    fn cause(&self) -> Option<&dyn (::std::error::Error)> {
+        match *self {
+            ShaderCreationError::Io(ref err) => Some(err),
+            _ => None,
+        }
+    }
+
+    fn description(&self) -> &str {
+        match *self {
+            ShaderCreationError::Io(ref err) => err.description(),
+            ShaderCreationError::Compile(ref _path, ref s) => s.as_str(),
+            ShaderCreationError::Link(ref s) => s.as_str(),
+        }
+    }
+}
+
+impl ::std::fmt::Display for ShaderCreationError {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        match *self {
+            ShaderCreationError::Io(ref err) => write!(f, "Couldn't read shader: {}", err),
+            ShaderCreationError::Compile(ref path, ref log) => {
+                write!(f, "Failed compiling shader at {}: {}", path.display(), log)
+            },
+            ShaderCreationError::Link(ref log) => write!(f, "Failed linking shader: {}", log),
+        }
+    }
+}
+
+impl From<io::Error> for ShaderCreationError {
+    fn from(val: io::Error) -> ShaderCreationError {
+        ShaderCreationError::Io(val)
+    }
+}
+
+/// Manages a single texture atlas
+///
+/// The strategy for filling an atlas looks roughly like this:
+///
+/// ```ignore
+///                           (width, height)
+///   ┌─────┬─────┬─────┬─────┬─────┐
+///   │ 10  │     │     │     │     │ <- Empty spaces; can be filled while
+///   │     │     │     │     │     │    glyph_height < height - row_baseline
+///   ├⎼⎼⎼⎼⎼┼⎼⎼⎼⎼⎼┼⎼⎼⎼⎼⎼┼⎼⎼⎼⎼⎼┼⎼⎼⎼⎼⎼┤
+///   │ 5   │ 6   │ 7   │ 8   │ 9   │
+///   │     │     │     │     │     │
+///   ├⎼⎼⎼⎼⎼┼⎼⎼⎼⎼⎼┼⎼⎼⎼⎼⎼┼⎼⎼⎼⎼⎼┴⎼⎼⎼⎼⎼┤ <- Row height is tallest glyph in row; this is
+///   │ 1   │ 2   │ 3   │ 4         │    used as the baseline for the following row.
+///   │     │     │     │           │ <- Row considered full when next glyph doesn't
+///   └─────┴─────┴─────┴───────────┘    fit in the row.
+/// (0, 0)  x->
+/// ```
+#[derive(Debug)]
+struct Atlas {
+    /// Texture id for this atlas
+    id: GLuint,
+
+    /// Width of atlas
+    width: i32,
+
+    /// Height of atlas
+    height: i32,
+
+    /// Left-most free pixel in a row.
+    ///
+    /// This is called the extent because it is the upper bound of used pixels
+    /// in a row.
+    row_extent: i32,
+
+    /// Baseline for glyphs in the current row
+    row_baseline: i32,
+
+    /// Tallest glyph in current row
+    ///
+    /// This is used as the advance when end of row is reached
+    row_tallest: i32,
+}
+
+/// Error that can happen when inserting a texture to the Atlas
+enum AtlasInsertError {
+    /// Texture atlas is full
+    Full,
+
+    /// The glyph cannot fit within a single texture
+    GlyphTooLarge,
+}
+
+impl Atlas {
+    fn new(size: i32) -> Atlas {
+        let mut id: GLuint = 0;
+        unsafe {
+            gl::PixelStorei(gl::UNPACK_ALIGNMENT, 1);
+            gl::GenTextures(1, &mut id);
+            gl::BindTexture(gl::TEXTURE_2D, id);
+            gl::TexImage2D(
+                gl::TEXTURE_2D,
+                0,
+                gl::RGB as i32,
+                size,
+                size,
+                0,
+                gl::RGB,
+                gl::UNSIGNED_BYTE,
+                ptr::null(),
+            );
+
+            gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, gl::CLAMP_TO_EDGE as i32);
+            gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_T, gl::CLAMP_TO_EDGE as i32);
+            gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR as i32);
+            gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR as i32);
+
+            gl::BindTexture(gl::TEXTURE_2D, 0);
+        }
+
+        Atlas { id, width: size, height: size, row_extent: 0, row_baseline: 0, row_tallest: 0 }
+    }
+
+    pub fn clear(&mut self) {
+        self.row_extent = 0;
+        self.row_baseline = 0;
+        self.row_tallest = 0;
+    }
+
+    /// Insert a RasterizedGlyph into the texture atlas
+    pub fn insert(
+        &mut self,
+        glyph: &RasterizedGlyph,
+        active_tex: &mut u32,
+    ) -> Result<Glyph, AtlasInsertError> {
+        if glyph.width > self.width || glyph.height > self.height {
+            return Err(AtlasInsertError::GlyphTooLarge);
+        }
+
+        // If there's not enough room in current row, go onto next one
+        if !self.room_in_row(glyph) {
+            self.advance_row()?;
+        }
+
+        // If there's still not room, there's nothing that can be done here.
+        if !self.room_in_row(glyph) {
+            return Err(AtlasInsertError::Full);
+        }
+
+        // There appears to be room; load the glyph.
+        Ok(self.insert_inner(glyph, active_tex))
+    }
+
+    /// Insert the glyph without checking for room
+    ///
+    /// Internal function for use once atlas has been checked for space. GL
+    /// errors could still occur at this point if we were checking for them;
+    /// hence, the Result.
+    fn insert_inner(&mut self, glyph: &RasterizedGlyph, active_tex: &mut u32) -> Glyph {
+        let offset_y = self.row_baseline;
+        let offset_x = self.row_extent;
+        let height = glyph.height as i32;
+        let width = glyph.width as i32;
+
+        unsafe {
+            gl::BindTexture(gl::TEXTURE_2D, self.id);
+
+            // Load data into OpenGL
+            gl::TexSubImage2D(
+                gl::TEXTURE_2D,
+                0,
+                offset_x,
+                offset_y,
+                width,
+                height,
+                gl::RGB,
+                gl::UNSIGNED_BYTE,
+                glyph.buf.as_ptr() as *const _,
+            );
+
+            gl::BindTexture(gl::TEXTURE_2D, 0);
+            *active_tex = 0;
+        }
+
+        // Update Atlas state
+        self.row_extent = offset_x + width;
+        if height > self.row_tallest {
+            self.row_tallest = height;
+        }
+
+        // Generate UV coordinates
+        let uv_bot = offset_y as f32 / self.height as f32;
+        let uv_left = offset_x as f32 / self.width as f32;
+        let uv_height = height as f32 / self.height as f32;
+        let uv_width = width as f32 / self.width as f32;
+
+        Glyph {
+            tex_id: self.id,
+            top: glyph.top as f32,
+            width: width as f32,
+            height: height as f32,
+            left: glyph.left as f32,
+            uv_bot,
+            uv_left,
+            uv_width,
+            uv_height,
+        }
+    }
+
+    /// Check if there's room in the current row for given glyph
+    fn room_in_row(&self, raw: &RasterizedGlyph) -> bool {
+        let next_extent = self.row_extent + raw.width as i32;
+        let enough_width = next_extent <= self.width;
+        let enough_height = (raw.height as i32) < (self.height - self.row_baseline);
+
+        enough_width && enough_height
+    }
+
+    /// Mark current row as finished and prepare to insert into the next row
+    fn advance_row(&mut self) -> Result<(), AtlasInsertError> {
+        let advance_to = self.row_baseline + self.row_tallest;
+        if self.height - advance_to <= 0 {
+            return Err(AtlasInsertError::Full);
+        }
+
+        self.row_baseline = advance_to;
+        self.row_extent = 0;
+        self.row_tallest = 0;
+
+        Ok(())
+    }
+}