148 lines
4.2 KiB
Rust
148 lines
4.2 KiB
Rust
use cosmic_text::{Attrs, AttrsList, Buffer, Family, FontSystem, Metrics, SwashCache};
|
|
use image::{Rgba, RgbaImage};
|
|
|
|
use crate::{
|
|
layout::{Align, TextureHandle, Textures, UiColor, Vec2},
|
|
util::HashMap,
|
|
};
|
|
|
|
/// TODO: properly wrap this
|
|
pub mod text_lib {
|
|
pub use cosmic_text::*;
|
|
}
|
|
|
|
pub struct TextData {
|
|
pub font_system: FontSystem,
|
|
pub swash_cache: SwashCache,
|
|
}
|
|
|
|
impl Default for TextData {
|
|
fn default() -> Self {
|
|
Self {
|
|
font_system: FontSystem::new(),
|
|
swash_cache: SwashCache::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
pub struct TextAttrs {
|
|
pub color: UiColor,
|
|
pub font_size: f32,
|
|
pub line_height: f32,
|
|
pub family: Family<'static>,
|
|
pub wrap: bool,
|
|
/// inner alignment of text region (within where its drawn)
|
|
pub align: Align,
|
|
}
|
|
|
|
impl TextAttrs {
|
|
pub fn apply(&self, font_system: &mut FontSystem, buf: &mut Buffer, width: Option<f32>) {
|
|
buf.set_metrics_and_size(
|
|
font_system,
|
|
Metrics::new(self.font_size, self.line_height),
|
|
width,
|
|
None,
|
|
);
|
|
let attrs = Attrs::new().family(self.family);
|
|
let list = AttrsList::new(&attrs);
|
|
for line in &mut buf.lines {
|
|
line.set_attrs_list(list.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type TextBuffer = Buffer;
|
|
|
|
impl Default for TextAttrs {
|
|
fn default() -> Self {
|
|
let size = 14.0;
|
|
Self {
|
|
color: UiColor::WHITE,
|
|
font_size: size,
|
|
line_height: size * 1.2,
|
|
family: Family::SansSerif,
|
|
wrap: false,
|
|
align: Align::Center,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TextData {
|
|
pub fn draw(
|
|
&mut self,
|
|
buffer: &mut TextBuffer,
|
|
attrs: &TextAttrs,
|
|
textures: &mut Textures,
|
|
) -> TextTexture {
|
|
// TODO: either this or the layout stuff (or both) is super slow,
|
|
// should probably do texture packing and things if possible.
|
|
// very visible if you add just a couple of wrapping texts and resize window
|
|
// should also be timed to figure out exactly what points need to be sped up
|
|
let mut pixels = HashMap::default();
|
|
let mut min_x = 0;
|
|
let mut min_y = 0;
|
|
let mut max_x = 0;
|
|
let mut max_y = 0;
|
|
let cosmic_color = {
|
|
let c = attrs.color;
|
|
cosmic_text::Color::rgba(c.r, c.g, c.b, c.a)
|
|
};
|
|
let mut max_width = 0.0f32;
|
|
let mut height = 0.0;
|
|
for run in buffer.layout_runs() {
|
|
for glyph in run.glyphs.iter() {
|
|
let physical_glyph = glyph.physical((0., 0.), 1.0);
|
|
|
|
let glyph_color = match glyph.color_opt {
|
|
Some(some) => some,
|
|
None => cosmic_color,
|
|
};
|
|
|
|
self.swash_cache.with_pixels(
|
|
&mut self.font_system,
|
|
physical_glyph.cache_key,
|
|
glyph_color,
|
|
|x, y, color| {
|
|
let x = physical_glyph.x + x;
|
|
let y = run.line_y as i32 + physical_glyph.y + y;
|
|
min_x = min_x.min(x);
|
|
min_y = min_y.min(y);
|
|
max_x = max_x.max(x);
|
|
max_y = max_y.max(y);
|
|
pixels.insert((x, y), Rgba(color.as_rgba()));
|
|
},
|
|
);
|
|
}
|
|
max_width = max_width.max(run.line_w);
|
|
height += run.line_height;
|
|
}
|
|
let img_width = (max_x - min_x + 1) as u32;
|
|
let img_height = (max_y - min_y + 1) as u32;
|
|
let mut image = RgbaImage::new(img_width, img_height);
|
|
for ((x, y), color) in pixels {
|
|
let x = (x - min_x) as u32;
|
|
let y = (y - min_y) as u32;
|
|
image.put_pixel(x, y, color);
|
|
}
|
|
TextTexture {
|
|
handle: textures.add(image),
|
|
top_left: Vec2::new(min_x as f32, min_y as f32),
|
|
bot_right: Vec2::new(max_width - max_x as f32, height - max_y as f32),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct TextTexture {
|
|
pub handle: TextureHandle,
|
|
pub top_left: Vec2,
|
|
pub bot_right: Vec2,
|
|
}
|
|
|
|
impl TextTexture {
|
|
pub fn size(&self) -> Vec2 {
|
|
self.handle.size() - self.top_left + self.bot_right
|
|
}
|
|
}
|