Struct Font

pub struct Font { /* private fields */ }

Implementations

impl Font

pub fn line_height(&self) -> f32

pub fn ascender(&self) -> f32

pub fn descender(&self) -> f32

pub fn space_width(&self) -> f32

pub fn texture_size(&self) -> Point2

pub fn calculate_text_size(&self, text: &str) -> Vector2

pub fn create_baked_text_raw( &self, text: &str, format: FontBakeFormat, ) -> Result<(Vec<u8>, u32, u32), String>

Bakes the text into a texture data buffer.

This is useful for rendering static text without needing to render each glyph individually.

pub fn save_font_cache(&self, path: &str) -> Result<(), Error>

Saves the font cache to a file.

This will create a binary file that can be loaded later using FontManager::load_font_cached.

pub fn get_image_data(&self) -> (Vec<u8>, u32, u32)

Returns the image data of the font texture atlas.

pub fn get_glyph(&self, codepoint: u32) -> Result<Glyph, FontError>

Returns the font’s glyph for the given codepoint.

pub fn create_baked_text( &self, gpu: &mut GPU, text: &str, ) -> Result<Texture, TextureError>

Create a texture from the baked text.

This is useful for rendering static text without needing to render each glyph individually.

Examples found in repository

examples/font.rs (line 25)

fn main() {
    let mut runner = est_render::runner::new().expect("Failed to create runner");

    let mut window = runner
        .create_window("Font Example", Point2::new(800, 600))
        .build()
        .expect("Failed to create window");

    let mut gpu = est_render::gpu::new(Some(&mut window))
        .build()
        .expect("Failed to create GPU");

    let mut font_manager = est_render::font::new();

    let font = font_manager
        .load_font("Arial", None, 20.0)
        .expect("Failed to load font");

    // Generate baked text texture
    let texture = font
        .create_baked_text(&mut gpu, "Hello, World!\nThis is a clear color example.")
        .expect("Failed to create baked text");

    while runner.pool_events(None) {
        for event in runner.get_events() {
            match event {
                Event::WindowClosed { .. } => {
                    return;
                }
                _ => {}
            }
        }

        if let Ok(mut cmd) = gpu.begin_command() {
            if let Ok(mut gp) = cmd.begin_renderpass() {
                gp.set_clear_color(Color::BLUE);

                // The best texture blend for font rendering, others may has artifacts like black borders
                gp.set_blend(0, Some(&BlendState::ADDITIVE_BLEND));
                
                if let Some(mut drawing) = gp.begin_drawing() {
                    let size: Vector2 = texture.size().into();

                    // Baked text rendering
                    drawing.set_texture(Some(&texture));
                    drawing.draw_rect_image(Vector2::new(0.0, 0.0), size, Color::WHITE);

                    // Online text rendering
                    drawing.set_font(&font);
                    drawing.draw_text(
                        "Hello, World!\nThis is a clear color example.",
                        Vector2::new(size.x, 0.0),
                        Color::WHITE,
                    );
                }
            }
        }
    }
}

pub fn create_texture(&self, gpu: &mut GPU) -> Result<Texture, TextureError>

Creates a texture from the font’s glyph atlas.

Trait Implementations

impl Clone for Font

fn clone(&self) -> Font

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Font

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.