293 lines
8.2 KiB
Rust
293 lines
8.2 KiB
Rust
use super::{DrawCommand, MeshIndex, MeshVertex};
|
|
|
|
use allsorts::binary::read::ReadScope;
|
|
use allsorts::font::MatchingPresentation;
|
|
use allsorts::font_data::{DynamicFontTableProvider, FontData as AllsortsFontData};
|
|
use allsorts::glyph_position::{GlyphLayout, TextDirection};
|
|
use allsorts::{tag, Font as AllsortsFont};
|
|
use canary_types::{Color, Rect, Vec2};
|
|
use ouroboros::self_referencing;
|
|
use parking_lot::Mutex;
|
|
use std::collections::HashMap;
|
|
use std::sync::atomic::{AtomicU32, Ordering};
|
|
use std::sync::Arc;
|
|
|
|
pub mod glyph;
|
|
|
|
use glyph::GlyphCache;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone, Debug)]
|
|
pub struct GlyphPosition {
|
|
pub index: u16,
|
|
pub hori_advance: i32,
|
|
pub vert_advance: i32,
|
|
pub xoff: i32,
|
|
pub yoff: i32,
|
|
}
|
|
|
|
pub struct TextLayout {
|
|
pub font_id: u32,
|
|
pub bounds: Rect,
|
|
pub glyphs: Vec<GlyphPosition>,
|
|
}
|
|
|
|
pub struct Font {
|
|
font_id: u32,
|
|
data: Mutex<FontData>,
|
|
glyph_cache: GlyphCache,
|
|
}
|
|
|
|
impl Font {
|
|
pub fn load(
|
|
font_id: u32,
|
|
script: u32,
|
|
direction: TextDirection,
|
|
vertical: bool,
|
|
file_buffer: Vec<u8>,
|
|
) -> Self {
|
|
let mut data = FontData::load(script, direction, vertical, file_buffer);
|
|
let glyph_cache = data.with_inner_mut(|font| GlyphCache::new(font));
|
|
let data = Mutex::new(data);
|
|
|
|
Self {
|
|
font_id,
|
|
data,
|
|
glyph_cache,
|
|
}
|
|
}
|
|
|
|
pub fn shape(&self, text: &str) -> TextLayout {
|
|
let positions = self.data.lock().shape(text);
|
|
let glyphs = self.glyph_cache.glyphs.read();
|
|
let mut bounds = Rect::NEG_INFINITY;
|
|
|
|
let units_per_em = self.glyph_cache.units_per_em;
|
|
let mut xcur = 0;
|
|
let mut ycur = 0;
|
|
for position in positions.iter() {
|
|
let xpos = xcur + position.xoff;
|
|
let ypos = ycur + position.yoff;
|
|
xcur += position.hori_advance;
|
|
ycur += position.vert_advance;
|
|
|
|
let xpos = xpos as f32 / units_per_em;
|
|
let ypos = ypos as f32 / units_per_em;
|
|
|
|
let mut bb = glyphs.get(position.index as usize).unwrap().bounding_box;
|
|
bb.bl.x = bb.bl.x + xpos;
|
|
bb.bl.y = bb.bl.y + ypos;
|
|
bb.tr.x = bb.tr.x + xpos;
|
|
bb.tr.y = bb.tr.y + ypos;
|
|
|
|
// TODO use euclid instead
|
|
if bounds.bl.x > bb.bl.x {
|
|
bounds.bl.x = bb.bl.x;
|
|
}
|
|
|
|
if bounds.bl.y > bb.bl.y {
|
|
bounds.bl.y = bb.bl.y;
|
|
}
|
|
|
|
if bounds.tr.x < bb.tr.x {
|
|
bounds.tr.x = bb.tr.x;
|
|
}
|
|
|
|
if bounds.tr.y < bb.tr.y {
|
|
bounds.tr.y = bb.tr.y;
|
|
}
|
|
}
|
|
|
|
TextLayout {
|
|
font_id: self.font_id,
|
|
bounds,
|
|
glyphs: positions,
|
|
}
|
|
}
|
|
|
|
pub fn draw(
|
|
&self,
|
|
positions: &[GlyphPosition],
|
|
offset: Vec2,
|
|
scale: f32,
|
|
color: Color,
|
|
) -> Vec<DrawCommand> {
|
|
let mut vertices = Vec::new();
|
|
let mut indices = Vec::new();
|
|
|
|
// TODO defer tessellation of missed glyph cache entries
|
|
let mut glyphs = self.glyph_cache.glyphs.write();
|
|
let units_per_em = self.glyph_cache.units_per_em;
|
|
let pos_scale = scale / units_per_em;
|
|
let mut xcur = 0;
|
|
let mut ycur = 0;
|
|
for position in positions.iter() {
|
|
let glyph = glyphs.get_mut(position.index as usize).unwrap().get_mesh();
|
|
|
|
let xpos = xcur + position.xoff;
|
|
let ypos = ycur + position.yoff;
|
|
xcur += position.hori_advance;
|
|
ycur += position.vert_advance;
|
|
|
|
let voff = vertices.len() as MeshIndex;
|
|
let xpos = xpos as f32 * pos_scale + offset.x;
|
|
let ypos = ypos as f32 * pos_scale + offset.y;
|
|
|
|
for v in glyph.vertices.iter() {
|
|
let x = v.x * scale + xpos;
|
|
let y = v.y * scale + ypos;
|
|
vertices.push(MeshVertex {
|
|
position: canary_types::Vec2 { x, y },
|
|
color,
|
|
});
|
|
}
|
|
|
|
for i in glyph.indices.iter() {
|
|
indices.push(i + voff);
|
|
}
|
|
}
|
|
|
|
vec![DrawCommand::Mesh { vertices, indices }]
|
|
}
|
|
}
|
|
|
|
#[self_referencing]
|
|
pub struct FontData {
|
|
file_buffer: Vec<u8>,
|
|
script: u32,
|
|
direction: TextDirection,
|
|
vertical: bool,
|
|
|
|
#[borrows(file_buffer)]
|
|
#[covariant]
|
|
read_scope: ReadScope<'this>,
|
|
|
|
#[borrows(read_scope)]
|
|
#[not_covariant]
|
|
font_data: AllsortsFontData<'this>,
|
|
|
|
#[borrows(font_data)]
|
|
#[covariant]
|
|
inner: AllsortsFont<DynamicFontTableProvider<'this>>,
|
|
}
|
|
|
|
impl FontData {
|
|
pub fn load(
|
|
script: u32,
|
|
direction: TextDirection,
|
|
vertical: bool,
|
|
file_buffer: Vec<u8>,
|
|
) -> Self {
|
|
FontDataBuilder {
|
|
file_buffer,
|
|
script,
|
|
direction,
|
|
vertical,
|
|
read_scope_builder: |buffer| ReadScope::new(buffer),
|
|
font_data_builder: |scope| scope.read::<AllsortsFontData<'_>>().unwrap(),
|
|
inner_builder: |font_data| {
|
|
AllsortsFont::new(font_data.table_provider(0).unwrap())
|
|
.unwrap()
|
|
.unwrap()
|
|
},
|
|
}
|
|
.build()
|
|
}
|
|
|
|
pub fn shape(&mut self, text: &str) -> Vec<GlyphPosition> {
|
|
let presentation = MatchingPresentation::Required;
|
|
let script = *self.borrow_script();
|
|
let lang_tag = None;
|
|
let features = allsorts::gsub::Features::default();
|
|
let kerning = true;
|
|
let direction = *self.borrow_direction();
|
|
let vertical = *self.borrow_vertical();
|
|
|
|
self.with_inner_mut(|font| {
|
|
let mapped = font.map_glyphs(text, script, presentation);
|
|
let infos = font
|
|
.shape(mapped, script, lang_tag, &features, kerning)
|
|
.unwrap();
|
|
let mut layout = GlyphLayout::new(font, &infos, direction, vertical);
|
|
let positions = layout.glyph_positions().unwrap();
|
|
let mut glyphs = Vec::with_capacity(positions.len());
|
|
for (glyph, position) in infos.iter().zip(&positions) {
|
|
glyphs.push(GlyphPosition {
|
|
index: glyph.glyph.glyph_index,
|
|
hori_advance: position.hori_advance,
|
|
vert_advance: position.vert_advance,
|
|
xoff: position.x_offset,
|
|
yoff: position.y_offset,
|
|
});
|
|
}
|
|
|
|
glyphs
|
|
})
|
|
}
|
|
}
|
|
|
|
pub struct FontStore {
|
|
source: Box<dyn font_kit::source::Source>,
|
|
loaded: Mutex<HashMap<String, Arc<Font>>>,
|
|
current_index: AtomicU32,
|
|
}
|
|
|
|
impl Default for FontStore {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl FontStore {
|
|
pub fn new() -> Self {
|
|
let source = font_kit::source::SystemSource::new();
|
|
let source = Box::new(source);
|
|
|
|
Self {
|
|
source,
|
|
loaded: Default::default(),
|
|
current_index: AtomicU32::new(0),
|
|
}
|
|
}
|
|
|
|
pub fn load_font(&self, title: &str) -> Arc<Font> {
|
|
let mut loaded = self.loaded.lock();
|
|
|
|
if let Some(loaded) = loaded.get(title) {
|
|
return loaded.to_owned();
|
|
}
|
|
|
|
use font_kit::family_name::FamilyName;
|
|
use font_kit::handle::Handle;
|
|
use font_kit::properties::Properties;
|
|
|
|
println!("loading font family {}", title);
|
|
|
|
let font_handle = self
|
|
.source
|
|
.select_best_match(&[FamilyName::Title(title.to_string())], &Properties::new())
|
|
.unwrap();
|
|
|
|
println!("loading font file: {:?}", font_handle);
|
|
|
|
let font_data = if let Handle::Path {
|
|
path,
|
|
font_index: _,
|
|
} = font_handle
|
|
{
|
|
std::fs::read(path).unwrap()
|
|
} else {
|
|
panic!("font is not a file for some reason");
|
|
};
|
|
|
|
let script = tag::LATN;
|
|
let face_index = self.current_index.fetch_add(1, Ordering::Relaxed);
|
|
let direction = TextDirection::LeftToRight;
|
|
let vertical = false;
|
|
let font = Font::load(face_index, script, direction, vertical, font_data.clone());
|
|
let font = Arc::new(font);
|
|
loaded.insert(title.to_string(), font.to_owned());
|
|
font
|
|
}
|
|
}
|