pistondevelopers / gfx_text Goto Github PK

View Code? Open in Web Editor NEW

22.0 47.0 12.0 493 KB

Draw text for gfx using freetype

Home Page: http://docs.piston.rs/gfx_text/gfx_text/

License: MIT License

Rust 100.00%

gfx_text's Introduction

gfx_text

Library for drawing text for gfx-rs graphics API. Uses freetype-rs underneath.

Usage

Basic usage:

// Initialize text renderer.
let mut text = gfx_text::new(factory).build().unwrap();

// In render loop:

// Add some text 10 pixels down and right from the top left screen corner.
text.add(
    "The quick brown fox jumps over the lazy dog",  // Text to add
    [10, 10],                                       // Position
    [0.65, 0.16, 0.16, 1.0],                        // Text color
);

// Draw text.
text.draw(&mut stream);

See API documentation for overview of all available methods.

You can skip default font by disabling include-font feature:

[dependencies.gfx_text]
version = "*"
default-features = false

Examples

See this example on how to draw text in various styles: different sizes, colors, fonts, etc.

Output:

License

gfx_text licensed under MIT License
Included by default Noto Sans font uses Apache License 2.0
Ubuntu Font used in examples has Ubuntu Font Licence 1.0

gfx_text's People

Contributors

Stargazers

Watchers

Forkers

kvark bvssvni aonorin guycook mattias-p bonsaiden elrnv pshc itadinanta nwoeanhinnogaehr marek-g theor

gfx_text's Issues

Outdated example

Now that gfx_window_glutin is deprecated in favour of glutin_window, the provided example in examples/styles.rs is out of date.
I would like to use gfx_text with the new glutin_window, but it seems to be somewhat involved?

Provide non-Canvas API as an alternative

Canvas should not be the only way to use this library. It would be more flexible to work with Stream and Factory types, while leaving the canvas API redirecting to them for convenience. See gfx-debug-draw for an example. Note: this will look better when factories start carrying their own capabilities.

Provide v120 shaders

Provide additional v120 shaders for better compatibility. See #39.

Multiple calls to draw_end on the same text seems to erase previous calls' result partially.

The following example code:

extern crate gfx;
extern crate gfx_window_glutin;
extern crate glutin;
extern crate gfx_text;

use gfx::traits::{IntoCanvas, Stream};
use gfx_window_glutin as gfxw;
use glutin::{WindowBuilder, Event, VirtualKeyCode, GL_CORE};

const BROWN: [f32; 4] = [0.65, 0.16, 0.16, 1.0];
const RED: [f32; 4] = [1.0, 0.0, 0.0, 1.0];

fn main() {
    let mut canvas = {
        let window = WindowBuilder::new()
            .with_dimensions(640, 480)
            .with_title(format!("gfx_text example"))
            .with_gl(GL_CORE)
            .build()
            .unwrap();
        gfxw::init(window).into_canvas()
    };

    let mut normal_text = gfx_text::new(&mut canvas.factory).unwrap();

    'main: loop {
        for event in canvas.output.window.poll_events() {
            match event {
                Event::Closed => break 'main,
                Event::KeyboardInput(_, _, Some(VirtualKeyCode::Escape)) => break 'main,
                _ => {},
            }
        }
        canvas.clear(gfx::ClearData {color: [1.0, 1.0, 1.0, 1.0], depth: 1.0, stencil: 0});

        normal_text.draw("The quick brown fox jumps over the lazy dog", [10, 10], BROWN);
        normal_text.draw_end(&mut canvas).unwrap();

        normal_text.draw("The quick brown fox jumps over the lazy dog", [30, 30], BROWN);
        normal_text.draw_end(&mut canvas).unwrap();

        normal_text.draw("The quick red fox jumps over the lazy dog", [50, 50], RED);
        normal_text.draw_end(&mut canvas).unwrap();

        canvas.present();
    }
}

Will give the following result:

This causes problems in applications where multiple calls to draw_end are done for layering.

Word wrapping

Fit text into the given width, wrap by spaces and also correctly recognize line breaks.

Was requested by @LaylConway on #rust.

Add more docs

Add #![deny(missing_docs)] at crate level to make it an compiler error.

Outline text

Implement outline.

Rewrite "examples/styles.txt" to use piston_window

gfx_glutin_window does not work very well on OSX.

Travis fails to build gfx_text with rust nightly

See e.g. https://travis-ci.org/PistonDevelopers/gfx_text/jobs/68330727

Add type aliases for arrays

There are some use of arrays like [i32; 2] which could be explained better by adding a type alias.

Only RGBA8 format supported

Neither HDR targets nor Srgba8 target are allowed. Draw is hardcoded on Rgba8.

What's the recommended workaround?

Avoid allocation per draw

gfx-rs itself doesn't use any allocations on a call-by-call basis, and it would be great if gfx_text didn't impose this overhead either. The allocations come from the constructed meshes and batches, even if implicit. What can be done:

have an OwnedBatch created once on init
update its Slice with updating the vertex/index buffers that the batch uses
send it to a stream as usual

Add API doc examples to most of the methods

A bunch of examples should be added to API docs. See Rust API docs for the inspiration.

Feature to not include the default font

Would be nice to have feature (enabled by default) to control the embedding of the default font because it weights 300 KiB and it's not that cheap.
Example of using features: https://github.com/PistonDevelopers/image

Measuring text size

This is a feature required to do common things such as centering text and implementing a text box. Perhaps like this:

let mut text = gfx_text::new(factory).build().unwrap();
let size: [i32; 2] = text.measure("Test Value");

Use rusttype instead of freetype-rs

See https://github.com/dylanede/rusttype

A pure Rust alternative to libraries like FreeType.

Support gfx 0.9

Mostly just raising this issue to let you know I've made a start to avoid any duplicated effort

gfx_text 0.13.1/0.13.0 unresolved import super::gfx using rust stable 1.13

Compiling gfx_text v0.13.1 error[E0432]: unresolved import super::gfx--> C:\Users\cube\.cargo\registry\src\github.com-1ecc6299db9ec823\gfx_text-0.13.1\src\lib.rs:567:5 | 567 | gfx_pipeline_base!( pipe { | ^ nogfxinshader_structs`
|
= note: this error originates in a macro outside of the current crate

error: aborting due to previous error

error: Could not compile gfx_text.

To learn more, run the command again with --verbose.
`

rustc 1.13.0 (2c6933acc 2016-11-07)

This is similar to #53 but does not seem to be the same.

Perspective divide not compensating for near clip distance

When running the hello_world example in turbine the text is drawn at larger offset from axes when turning up the near clip distance. It seems that this should be compensated such that the text keeps same offset.

Error types don't implement Error

It'd be convenient for error_chain purposes.

I could probably write a PR if you like!

Retina screen support

On retina screens, the frame buffer is twice the size of the internal window size in each direction. When one renders text, one might want to compensate for this. In piston-graphics this is done through the viewport library https://github.com/pistondevelopers/viewport

Use single-component texture for font bitmap

Since freetype provides grayscaled data, it's a waste of space and probably efficiency to store additional meanignless zeroes. I tried to use gfx::tex::R8 and t_Font_Color.r instead of .a in shader but sometimes was getting artifacts because of that.

Probably there is some error in shader and/or library code or you can't just blend R8 texture with vec4 color provided by user with default texture sampler. Needs additional investigation.

cc @kvark

Delete branch "images"

It seems the "images" branch is no longer needed.

Basic usage exampe not compiling

I can't make basic usage example in the Readme.md compile. The example says:

// Initialize text renderer.
let mut text = gfx_text::new(factory).build().unwrap();

// In render loop:

// Add some text 10 pixels down and right from the top left screen corner.
text.add(
    "The quick brown fox jumps over the lazy dog",  // Text to add
    [10, 10],                                       // Position
    [0.65, 0.16, 0.16, 1.0],                        // Text color
);

// Draw text.
text.draw(&mut stream);

But there is no method draw on Renderer that takes a stream as a parameter, there is only

fn draw<C: CommandBuffer<R>>(&mut self, encoder: &mut Encoder<R, C>, target: &RenderTargetView<R, Rgba8>) -> Result<(), Error>

Text Shaping Engine

Motivation

Currently the library can't work with complex text layout (ex: Arabic, Hindi, Tibetan). Hence, it is necessary to create a text shaping engine to tell how to choose and position glyphs.

Harfbuzz is a mature text shaping lib used by many opensource projects. We can add complex text shaping capability to gfx_text with it.

rusttype also plans to support complex text layout. However, for now it is not in higher priority.

Harfbuzz Examples

Update to latest Gfx

Could not figure out how to get this line working https://github.com/PistonDevelopers/gfx_text/blob/master/src/lib.rs#L445