Method new

src/graphics/text.rs:51–113

(gfx: &Graphics, font: &Font, size: f32)

impl SpriteFont {
    pub fn new(gfx: &Graphics, font: &Font, size: f32) -> SpriteFont {
        // TODO: Refactor to pack then allocate
        let mut packer = ShelfPacker::new(gfx, 256, 256);
        let mut cache = HashMap::new();
        let mut kerning = HashMap::new();

        let line_metrics = font.data.horizontal_line_metrics(size).unwrap();

        for ch in 32u8..128 {
            let ch = ch as char;

            let (metrics, data) = font.data.rasterize(ch, size);

            let image = if !data.is_empty() {
                let data: Vec<u8> = data.into_iter().flat_map(|x| [x, x, x, x]).collect();

                let uv = packer
                    .insert(
                        &data,
                        metrics.width as i32,
                        metrics.height as i32,
                        ATLAS_PADDING,
                    )
                    .expect("out of space");

                Some(SpriteFontGlyphImage {
                    offset: Vec2::new(
                        metrics.bounds.xmin - ATLAS_PADDING as f32,
                        -metrics.bounds.height - metrics.bounds.ymin - ATLAS_PADDING as f32,
                    ),
                    uv: Rectangle::new(uv.x as f32, uv.y as f32, uv.width as f32, uv.height as f32),
                })
            } else {
                None
            };

            cache.insert(
                ch,
                SpriteFontGlyph {
                    advance: metrics.advance_width,
                    image,
                },
            );

            for ch2 in 32u8..128 {
                let ch2 = ch2 as char;

                if let Some(k) = font.data.horizontal_kern(ch, ch2, size) {
                    kerning.insert((ch, ch2), k);
                }
            }
        }

        SpriteFont {
            ascent: line_metrics.ascent,
            descent: line_metrics.descent,
            line_gap: line_metrics.line_gap,