Add font support

CHANGES.md

@@ -7,6 +7,9 @@
 - Add `exhaust` and `reset` function to timer so they can be used for more than just an update cycle
 - `lifecycle::run` can now accept any kind of Error.
 - Add `into_raw_context` on Graphics, to allow lower-level graphics programming
+- Add font support!
+  - `VectorFont` allows you to load TTF files via rusttype
+  - `FontRenderer` allows you to draw glyphs to the screen
 
 ## v0.4.0-alpha0.3
 - Update `golem` to `v0.1.1` to fix non-power-of-2 textures

Cargo.toml

@@ -14,29 +14,33 @@ edition = "2018"
 
 [features]
 # complex_shapes, fonts, gamepads, sounds
-default = ["easy-log", "event-cache", "gamepad", "saving"]
+default = ["easy-log", "event-cache", "font", "gamepad", "saving", "ttf"]
 
 easy-log = ["simple_logger", "web_logger"]
 event-cache = ["blinds/event-cache"]
+font = ["elefont"]
 gamepad = ["blinds/gamepad"]
 saving = ["gestalt"]
 stdweb = ["gestalt/stdweb", "platter/stdweb", "blinds/stdweb", "golem/stdweb","instant/stdweb"]
 web-sys = ["gestalt/web-sys", "platter/web-sys", "blinds/web-sys", "golem/web-sys","instant/web-sys"]
+ttf = ["elefont/rusttype", "rusttype"]
 
 [badges]
 
 maintenance = { status = "actively-developed" }
 
 [dependencies]
+blinds = { version = "0.1.0", default-features = false, features = ["gl"] }
 bytemuck = "1.0"
+elefont = { version = "0.1.3", features = ["rusttype", "unicode-normalization"], optional = true }
 gestalt = { version = "0.1", optional = true }
 golem = { version = "0.1.3", features = ["std"] }
 image = { version = "0.22", default-features = false, features = ["png_codec", "jpeg"] }
+instant = "0.1.2"
 log = "0.4"
 mint = "0.5.3"
 platter = "0.1"
-blinds = { version = "0.1.0", default-features = false, features = ["gl"] }
-instant = "0.1.2"
+rusttype = { version = "0.8.2", optional = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 simple_logger = { version = "1.4", optional = true }

README.md

@@ -9,10 +9,10 @@ A simple 2D game framework written in pure Rust, for both the Web and Desktop
 
 ## Alpha Notice
 
-This version of Quicksilver is currently in a very early alpha! There are still planned changes
-to the API, some of them breaking. Additionally, major features (like audio support or text, for
-example) are entirely missing. Use at your own risk! Feedback on alpha-related bugs or the API
-changes from the 0.3.x API to the new API would be appreciated.
+This version of Quicksilver is currently working its way through alpha! There is still work to do
+on the API and on bugfixes, as well as waiting on an upstream library for audio support.
+Please feel free to use this version and **provide feedback!** If you run into bugs or want to
+give feedback on API decisions, please open an issue.
 
 ## A quick example
 
@@ -127,8 +127,8 @@ favorite browser to the port it provides.
 #### wasm-bindgen support
 
 Quicksilver has recently gained experimental support for `wasm-bindgen`, under the `web-sys`
-feature. The workflow is not currently documented here, but it should be the same as any other
-library.
+feature. The workflow is not currently documented here, but it should be the same as using any other
+library with `wasm-bindgen`.
 
 ## Optional Features
 
@@ -141,6 +141,7 @@ The optional features available are:
 [web_logger](https://github.com/yewstack/web_logger))
 - gamepad event generation (via [gilrs](https://gitlab.com/gilrs-project/gilrs))
 - saving (via [gestalt](https://github.com/ryanisaacg/gestalt))
+- font rendering (via [elefont](https://github.com/ryanisaacg/elefont)) and TTF parsing (via [rusttype](https://gitlab.redox-os.org/redox-os/rusttype))
 
 Each are enabled by default, but you can
 [specify which features](https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#choosing-features)

examples/07_text.rs

@@ -0,0 +1,38 @@
+// Example 7: Text
+// Write some text on the screen
+use quicksilver::{
+    geom::Vector,
+    graphics::{Color, Graphics, VectorFont},
+    lifecycle::{run, EventStream, Settings, Window},
+    Result,
+};
+
+fn main() {
+    run(
+        Settings {
+            size: Vector::new(800.0, 600.0).into(),
+            title: "Font Example",
+            ..Settings::default()
+        },
+        app,
+    );
+}
+
+async fn app(window: Window, mut gfx: Graphics, mut events: EventStream) -> Result<()> {
+    // Load the Font, just like loading any other asset
+    let ttf = VectorFont::load("font.ttf").await?;
+    let mut font = ttf.to_renderer(&gfx, 72.0)?;
+    gfx.clear(Color::WHITE);
+    // Use the font rendering API to draw some text
+    font.draw(
+        &mut gfx,
+        "Hello world!\nHello Quicksilver!",
+        Color::BLACK,
+        Vector::new(100.0, 100.0),
+    )?;
+    gfx.present(&window)?;
+
+    loop {
+        while let Some(_) = events.next_event().await {}
+    }
+}

src/error.rs

@@ -22,6 +22,24 @@ pub enum QuicksilverError {
     SurfaceImageError,
     /// A surface operation was attempted with no image bound to the surface
     NoSurfaceImageBound,
+    #[cfg(feature = "font")]
+    FontError(FontError),
+}
+
+#[cfg(feature = "font")]
+#[derive(Debug)]
+pub enum FontError {
+    /// A non-renderable glyph was passed to a font rendering function
+    ///
+    /// Generally this means the glyph was not included in the font, e.g. passing a non-ASCII
+    /// character to an ASCII-only font
+    NonRenderableGlyph(elefont::Glyph),
+    /// The string passed to the font (at the given size) is too large to render
+    ///
+    /// Because glyphs are cached on the GPU, a given character or word may be too large to render.
+    /// This is unlikely to be an issue for most applications, but if a character is rendered at a
+    /// size larger than 2048x2048, this error may occur.
+    StringTooLarge,
 }
 
 impl From<ImageError> for QuicksilverError {
@@ -42,6 +60,13 @@ impl From<GolemError> for QuicksilverError {
     }
 }
 
+#[cfg(feature = "font")]
+impl From<FontError> for QuicksilverError {
+    fn from(err: FontError) -> QuicksilverError {
+        QuicksilverError::FontError(err)
+    }
+}
+
 impl Display for QuicksilverError {
     fn fmt(&self, fmt: &mut Formatter) -> FmtResult {
         match self {
@@ -56,6 +81,13 @@ impl Display for QuicksilverError {
                 fmt,
                 "A surface operation was attempted with no image bound to the surface"
             ),
+            QuicksilverError::FontError(FontError::NonRenderableGlyph(g)) => {
+                write!(fmt, "This glyph cannot be rendered: {:?}", g)
+            }
+            QuicksilverError::FontError(FontError::StringTooLarge) => write!(
+                fmt,
+                "A word or glyph passed to a font was too large to render."
+            ),
         }
     }
 }

src/graphics.rs

@@ -13,12 +13,16 @@ use crate::QuicksilverError;
 
 mod circle_points;
 mod color;
+#[cfg(feature = "font")]
+mod font;
 mod image;
 mod mesh;
 mod surface;
 mod vertex;
 
 pub use self::color::Color;
+#[cfg(feature = "font")]
+pub use self::font::{FontRenderer, LayoutGlyph, VectorFont};
 pub use self::image::Image;
 pub use self::mesh::Mesh;
 pub use self::surface::Surface;