aboutsummaryrefslogtreecommitdiff
path: root/src/renderer
diff options
context:
space:
mode:
Diffstat (limited to 'src/renderer')
-rw-r--r--src/renderer/lines.rs143
-rw-r--r--src/renderer/mod.rs124
2 files changed, 200 insertions, 67 deletions
diff --git a/src/renderer/lines.rs b/src/renderer/lines.rs
new file mode 100644
index 00000000..556dcb0d
--- /dev/null
+++ b/src/renderer/lines.rs
@@ -0,0 +1,143 @@
+// 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 crate::term::{ SizeInfo, RenderableCell};
+use crate::term::cell::Flags;
+use crate::renderer::Rect;
+use font::Metrics;
+use crate::Rgb;
+
+/// Lines for underline and strikeout.
+pub struct Lines<'a> {
+ inner: Vec<(Rect<f32>, Rgb)>,
+ last_starts: HashMap<Flags, Option<RenderableCell>>,
+ last_cell: Option<RenderableCell>,
+ metrics: &'a Metrics,
+ size: &'a SizeInfo,
+}
+
+impl<'a> Lines<'a> {
+ pub fn new(metrics: &'a Metrics, size: &'a SizeInfo) -> Self {
+ let mut last_starts = HashMap::new();
+ last_starts.insert(Flags::UNDERLINE, None);
+ last_starts.insert(Flags::STRIKEOUT, None);
+
+ Self {
+ inner: Vec::new(),
+ last_cell: None,
+ last_starts,
+ metrics,
+ size,
+ }
+ }
+
+ /// Convert the stored lines to rectangles for the renderer.
+ pub fn rects(mut self) -> Vec<(Rect<f32>, Rgb)> {
+ // If there's still a line pending, draw it until the last cell
+ for (flag, start_cell) in self.last_starts.iter_mut() {
+ if let Some(start) = start_cell {
+ self.inner.push(
+ create_rect(
+ &start,
+ &self.last_cell.unwrap(),
+ *flag,
+ &self.metrics,
+ &self.size,
+ )
+ );
+ }
+ }
+
+ self.inner
+ }
+
+ /// Update the stored lines with the next cell info.
+ pub fn update_lines(&mut self, cell: &RenderableCell) {
+ for (flag, start_cell) in self.last_starts.iter_mut() {
+ let flag = *flag;
+ *start_cell = match *start_cell {
+ // Check for end if line is present
+ Some(ref mut start) => {
+ // No change in line
+ if cell.line == start.line && cell.flags.contains(flag) && cell.fg == start.fg {
+ continue;
+ }
+
+ self.inner.push(
+ create_rect(
+ &start,
+ &self.last_cell.unwrap(),
+ flag,
+ &self.metrics,
+ &self.size,
+ )
+ );
+
+ // Start a new line if the flag is present
+ if cell.flags.contains(flag) {
+ Some(*cell)
+ } else {
+ None
+ }
+ }
+ // Check for new start of line
+ None => if cell.flags.contains(flag) {
+ Some(*cell)
+ } else {
+ None
+ },
+ };
+ }
+
+ self.last_cell = Some(*cell);
+ }
+}
+
+/// Create a rectangle between two cells.
+fn create_rect(
+ start: &RenderableCell,
+ end: &RenderableCell,
+ flag: Flags,
+ metrics: &Metrics,
+ size: &SizeInfo,
+) -> (Rect<f32>, Rgb) {
+ let start_x = start.column.0 as f32 * size.cell_width;
+ let end_x = (end.column.0 + 1) as f32 * size.cell_width;
+ let width = end_x - start_x;
+
+ let (position, height) = match flag {
+ Flags::UNDERLINE => (metrics.underline_position, metrics.underline_thickness),
+ Flags::STRIKEOUT => (metrics.strikeout_position, metrics.strikeout_thickness),
+ _ => unimplemented!("Invalid flag for cell line drawing specified"),
+ };
+
+ let cell_bottom = (start.line.0 as f32 + 1.) * size.cell_height;
+ let baseline = cell_bottom + metrics.descent;
+
+ let mut y = baseline - position - height / 2.;
+ let max_y = cell_bottom - height;
+ if y > max_y {
+ y = max_y;
+ }
+
+ let rect = Rect::new(
+ start_x + size.padding_x,
+ y + size.padding_y,
+ width,
+ height,
+ );
+
+ (rect, start.fg)
+}
diff --git a/src/renderer/mod.rs b/src/renderer/mod.rs
index c05301cc..42a17486 100644
--- a/src/renderer/mod.rs
+++ b/src/renderer/mod.rs
@@ -23,16 +23,19 @@ use std::time::Duration;
use cgmath;
use fnv::FnvHasher;
+use glutin::dpi::PhysicalSize;
use font::{self, FontDesc, FontKey, GlyphKey, Rasterize, RasterizedGlyph, Rasterizer};
+use notify::{watcher, DebouncedEvent, RecursiveMode, Watcher};
+
use crate::gl::types::*;
use crate::gl;
use crate::index::{Column, Line, RangeInclusive};
-use notify::{watcher, DebouncedEvent, RecursiveMode, Watcher};
use crate::Rgb;
-
use crate::config::{self, Config, Delta};
use crate::term::{self, cell, RenderableCell};
-use glutin::dpi::PhysicalSize;
+use crate::renderer::lines::Lines;
+
+pub mod lines;
// Shader paths for live reload
static TEXT_SHADER_F_PATH: &'static str = concat!(env!("CARGO_MANIFEST_DIR"), "/res/text.f.glsl");
@@ -699,6 +702,7 @@ impl QuadRenderer {
config: &Config,
props: &term::SizeInfo,
visual_bell_intensity: f64,
+ cell_line_rects: Lines,
) {
// Swap to rectangle rendering program
unsafe {
@@ -725,6 +729,11 @@ impl QuadRenderer {
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
@@ -902,7 +911,8 @@ impl QuadRenderer {
}
}
-struct Rect<T> {
+#[derive(Debug, Copy, Clone)]
+pub struct Rect<T> {
x: T,
y: T,
width: T,
@@ -910,7 +920,7 @@ struct Rect<T> {
}
impl<T> Rect<T> {
- fn new(x: T, y: T, width: T, height: T) -> Self {
+ pub fn new(x: T, y: T, width: T, height: T) -> Self {
Rect { x, y, width, height }
}
}
@@ -998,7 +1008,9 @@ impl<'a> RenderApi<'a> {
})
.collect::<Vec<_>>();
- self.render_cells(cells.iter(), glyph_cache);
+ for cell in cells {
+ self.render_cell(cell, glyph_cache);
+ }
}
#[inline]
@@ -1016,74 +1028,52 @@ impl<'a> RenderApi<'a> {
}
}
- pub fn render_cells<'b, I>(
- &mut self,
- cells: I,
- glyph_cache: &mut GlyphCache
- )
- where I: Iterator<Item=&'b RenderableCell>
- {
- for cell in cells {
- // 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 {
- cell.chars
- };
+ pub fn render_cell(&mut self, cell: RenderableCell, glyph_cache: &mut GlyphCache) {
+ // 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
+ };
- // Render tabs as spaces in case the font doesn't support it
- if chars[0] == '\t' {
- chars[0] = ' ';
- }
+ // Don't render text of HIDDEN cells
+ let mut chars = if cell.flags.contains(cell::Flags::HIDDEN) {
+ [' '; cell::MAX_ZEROWIDTH_CHARS + 1]
+ } else {
+ cell.chars
+ };
- let mut glyph_key = GlyphKey {
- font_key,
- size: glyph_cache.font_size,
- c: chars[0],
- };
+ // Render tabs as spaces in case the font doesn't support it
+ if chars[0] == '\t' {
+ chars[0] = ' ';
+ }
- // Add cell to batch
- let glyph = glyph_cache.get(glyph_key, self);
- self.add_render_item(&cell, glyph);
+ let mut glyph_key = GlyphKey {
+ font_key,
+ size: glyph_cache.font_size,
+ c: chars[0],
+ };
- // 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);
+ // Add cell to batch
+ let glyph = glyph_cache.get(glyph_key, self);
+ self.add_render_item(&cell, glyph);
- // 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;
+ // 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);
- self.add_render_item(&cell, &glyph);
- }
+ // 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;
- // FIXME This is a super hacky way to do underlined text. During
- // a time crunch to release 0.1, this seemed like a really
- // easy, clean hack.
- if cell.flags.contains(cell::Flags::UNDERLINE) {
- let glyph_key = GlyphKey {
- font_key,
- size: glyph_cache.font_size,
- c: '_',
- };
-
- let underscore = glyph_cache.get(glyph_key, self);
- self.add_render_item(&cell, underscore);
- }
+ self.add_render_item(&cell, &glyph);
}
}
}
generated by cgit (git 2.34.1) at 2025-07-17 12:35:38 +0000