You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
85 lines
2.1 KiB
85 lines
2.1 KiB
//! Textium is a small library that wires Rusttype up to OpenGL.
|
|
//!
|
|
//! Textium provides a glyph atlas, atlas packers, a glyph rasterizer, and the necessary
|
|
//! shaders and infrastructure to easily connect to (at the moment) Glium.
|
|
//!
|
|
//! A future goal is making rendering backends generic.
|
|
|
|
extern crate rusttype;
|
|
#[macro_use]
|
|
extern crate glium;
|
|
|
|
mod error;
|
|
pub mod texture;
|
|
pub mod geometry;
|
|
pub mod rasterizer;
|
|
pub mod packer;
|
|
pub mod cache;
|
|
|
|
use std::collections::HashMap;
|
|
use std::hash::{Hash, Hasher};
|
|
use glium::texture::Texture2d;
|
|
|
|
pub use error::Error;
|
|
pub use geometry::Rect;
|
|
pub use rasterizer::Font;
|
|
|
|
/// Information used to render a glyph in a font.
|
|
#[derive(Debug, Clone)]
|
|
pub struct GlyphMetadata {
|
|
/// Bounding box in the packed texture
|
|
bounding_box: Rect<usize>,
|
|
/// Scale that the character was rendered at
|
|
scale: f32,
|
|
|
|
/// Distance between the bottom of the glyph and the baseline, in ems.
|
|
// baseline_distance: f32,
|
|
|
|
/// Distance to advance in layout after this character
|
|
advance_width: f32,
|
|
|
|
/// Horizontal offset between glyph origin and leftmost point of the glyph
|
|
left_bearing: f32,
|
|
}
|
|
|
|
/// Maps glyphs to their size, location, and rendering properties in a glyph atlas.
|
|
#[derive(Debug)]
|
|
pub struct FontAtlas {
|
|
pub glyph_metadata: HashMap<char, GlyphMetadata>
|
|
}
|
|
|
|
impl FontAtlas {
|
|
pub fn info(&self, chr: char) -> Option<GlyphMetadata> {
|
|
self.glyph_metadata.get(&chr).cloned()
|
|
}
|
|
}
|
|
|
|
/// A GPU-backed font texture, plus a [`FontAtlas`].
|
|
///
|
|
/// [`FontAtlas`]: struct.FontAtlas.html
|
|
pub struct FontTexture {
|
|
/// The GPU texture of packed glyphs.
|
|
pub data: Texture2d,
|
|
|
|
/// Atlas describing where glyphs are.
|
|
pub atlas: FontAtlas,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
struct Scale(f32);
|
|
impl Scale {
|
|
fn canonicalize(&self) -> i64 {
|
|
(self.0 * 1024.0 * 1024.0).round() as i64
|
|
}
|
|
}
|
|
impl PartialEq for Scale {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.canonicalize() == other.canonicalize()
|
|
}
|
|
}
|
|
impl Eq for Scale {}
|
|
impl Hash for Scale {
|
|
fn hash<H>(&self, state: &mut H) where H: Hasher {
|
|
self.canonicalize().hash(state);
|
|
}
|
|
}
|