canary-rs/src/text.rs

use super::{DrawCommand, MeshIndex, MeshVertex};

use allsorts::binary::read::ReadScope;
use allsorts::cff::CFF;
use allsorts::font::{GlyphTableFlags, MatchingPresentation};
use allsorts::font_data::FontData;
use allsorts::glyph_position::{GlyphLayout, TextDirection};
use allsorts::outline::OutlineBuilder;
use allsorts::pathfinder_geometry::{line_segment::LineSegment2F, vector::Vector2F};
use allsorts::tables::{glyf::GlyfTable, loca::LocaTable};
use allsorts::tables::{FontTableProvider, SfntVersion};
use allsorts::{tag, Font};
use std::collections::HashMap;

const TEXT_SCALE: f32 = 0.0001;

pub struct GlyphCache {
    glyphs: HashMap<u16, CachedGlyph>,
}

impl GlyphCache {
    pub fn new() -> Self {
        Self {
            glyphs: Default::default(),
        }
    }

    pub fn write_glyph(&mut self, builder: &mut impl OutlineBuilder, index: u16) {
        let mut sink = OutlineSink::new();
        builder.visit(index, &mut sink).unwrap();
        let path = sink.builder.build();

        use lyon::tessellation::*;
        let mut geometry: VertexBuffers<MeshVertex, MeshIndex> = VertexBuffers::new();
        let mut tessellator = FillTessellator::new();

        tessellator
            .tessellate_path(
                &path,
                &FillOptions::default(),
                &mut BuffersBuilder::new(&mut geometry, |vertex: FillVertex| {
                    let position = vertex.position() * TEXT_SCALE;
                    let position = canary_types::Vec2 {
                        x: position.x,
                        y: position.y,
                    };

                    MeshVertex {
                        position,
                        color: canary_types::Color::WHITE,
                    }
                }),
            )
            .unwrap();

        self.glyphs.insert(
            index,
            CachedGlyph {
                vertices: geometry.vertices,
                indices: geometry.indices,
            },
        );
    }
}

pub struct CachedGlyph {
    vertices: Vec<MeshVertex>,
    indices: Vec<MeshIndex>,
}

pub struct DummyText {
    vertices: Vec<MeshVertex>,
    indices: Vec<MeshIndex>,
}

impl Default for DummyText {
    fn default() -> Self {
        let script = tag::LATN;
        let buffer = include_bytes!("linja-pona-4.9.otf");
        let buffer = buffer.as_slice();
        let scope = ReadScope::new(&buffer);
        let font_file = scope.read::<FontData<'_>>().unwrap();
        let provider = font_file.table_provider(0).unwrap();
        let mut font = Font::new(provider).unwrap().unwrap();

        let text = "toki o! nimi mi li [_mun_alasa_sona]. toki+pona li pona.";
        let glyphs = font.map_glyphs(&text, script, MatchingPresentation::Required);

        let mut cache = GlyphCache::new();

        if font.glyph_table_flags.contains(GlyphTableFlags::CFF)
            && font.font_table_provider.sfnt_version() == tag::OTTO
        {
            let cff_data = font.font_table_provider.read_table_data(tag::CFF).unwrap();
            let mut cff = ReadScope::new(&cff_data).read::<CFF<'_>>().unwrap();

            println!("warming cache with {} glyphs", font.num_glyphs());
            for index in 0..font.num_glyphs() {
                cache.write_glyph(&mut cff, index);
            }
        } else if font.glyph_table_flags.contains(GlyphTableFlags::GLYF) {
            let loca_data = font.font_table_provider.read_table_data(tag::LOCA).unwrap();
            let loca = ReadScope::new(&loca_data)
                .read_dep::<LocaTable<'_>>((
                    usize::from(font.maxp_table.num_glyphs),
                    font.head_table().unwrap().unwrap().index_to_loc_format,
                ))
                .unwrap();
            let glyf_data = font.font_table_provider.read_table_data(tag::GLYF).unwrap();
            let mut glyf = ReadScope::new(&glyf_data)
                .read_dep::<GlyfTable<'_>>(&loca)
                .unwrap();

            println!("warming cache with {} glyphs", font.num_glyphs());
            for index in 0..font.num_glyphs() {
                cache.write_glyph(&mut glyf, index);
            }
        } else {
            panic!("no glyf or CFF table");
        }

        let lang_tag = None;
        let features = allsorts::gsub::Features::default();
        let kerning = true;
        let infos = font
            .shape(glyphs, script, lang_tag, &features, kerning)
            .unwrap();

        let direction = TextDirection::LeftToRight;
        let vertical = false;
        let mut layout = GlyphLayout::new(&mut font, &infos, direction, vertical);
        let positions = layout.glyph_positions().unwrap();

        let mut mesh = Self {
            vertices: Vec::new(),
            indices: Vec::new(),
        };

        let mut xcur = 0;
        let mut ycur = 0;
        for (glyph, position) in infos.iter().zip(&positions) {
            let xpos = xcur + position.x_offset;
            let ypos = ycur + position.y_offset;
            xcur += position.hori_advance;
            ycur += position.vert_advance;

            println!("({}, {}): {:#?}", xpos, ypos, glyph);

            // TODO refactor
            let glyph = cache.glyphs.get(&glyph.glyph.glyph_index).unwrap();
            let voff = mesh.vertices.len() as MeshIndex;
            let xoff = (xpos as f32) * TEXT_SCALE;
            let yoff = (ypos as f32) * TEXT_SCALE;

            for v in glyph.vertices.iter() {
                let x = v.position.x + xoff - 0.9;
                let y = v.position.y + yoff + 0.5;
                mesh.vertices.push(MeshVertex {
                    position: canary_types::Vec2 { x, y },
                    color: v.color,
                });
            }

            for i in glyph.indices.iter() {
                mesh.indices.push(i + voff);
            }
        }

        mesh
    }
}

impl DummyText {
    pub fn draw(&self, cmds: &mut Vec<DrawCommand>) {
        cmds.push(DrawCommand::Mesh {
            vertices: self.vertices.clone(),
            indices: self.indices.clone(),
        });
    }
}

pub struct OutlineSink {
    builder: lyon::path::path::Builder,
}

impl OutlineSink {
    pub fn new() -> Self {
        Self {
            builder: lyon::path::Path::builder(),
        }
    }

    fn pf_line_to_lyon(line: &LineSegment2F) -> (lyon::geom::Point<f32>, lyon::geom::Point<f32>) {
        (
            Self::pf_vector_to_lyon(&line.from()),
            Self::pf_vector_to_lyon(&line.to()),
        )
    }

    fn pf_vector_to_lyon(v: &Vector2F) -> lyon::geom::Point<f32> {
        lyon::geom::Point::<f32>::new(v.x(), v.y())
    }
}

impl allsorts::outline::OutlineSink for OutlineSink {
    fn move_to(&mut self, to: Vector2F) {
        let to = Self::pf_vector_to_lyon(&to);
        self.builder.begin(to);
    }

    fn line_to(&mut self, to: Vector2F) {
        let to = Self::pf_vector_to_lyon(&to);
        self.builder.line_to(to);
    }

    fn quadratic_curve_to(&mut self, control: Vector2F, to: Vector2F) {
        let control = Self::pf_vector_to_lyon(&control);
        let to = Self::pf_vector_to_lyon(&to);
        self.builder.quadratic_bezier_to(control, to);
    }

    fn cubic_curve_to(&mut self, control: LineSegment2F, to: Vector2F) {
        let (ctrl1, ctrl2) = Self::pf_line_to_lyon(&control);
        let to = Self::pf_vector_to_lyon(&to);
        self.builder.cubic_bezier_to(ctrl1, ctrl2, to);
    }

    fn close(&mut self) {
        self.builder.close();
    }
}