Text Rendering In UEFI GOP

[vengestone-dragoon]

im not sure if this is the correct place. i also am not sure if this is a bug with embedded-graphics or embedded-graphics-gop. my guess would be that its an issue with embedded-graphics-gop.
regardless of what i have tried, i cannot see text rendered to the display buffer. i have hunted around and found nothing other than what i have should work, but isn't working.

I am compiling for x86_64-unknown-uefi, and can confirm that the program runs both in a vm and on real hardware, with the same issues on both.
this is my text rendering code:

    let character_style = MonoTextStyle::new(&FONT_6X10, Rgb888::new(255, 255, 255)); 
    let text_style = TextStyleBuilder::new().line_height(LineHeight::Pixels(50)).build();

    Text::with_text_style(
        "Hello, UEFI!",
        Point::new(50, 150), 
        character_style,
        text_style,
    )
        .draw(&mut display)
        .unwrap();
    display.commit().unwrap();

Embedded-graphics-gop implements the display trait, and work for rendering shapes, but text and bmp images is not working for me.
Any help either getting this to actually work or identifying the actual problem would be apreciated.
here is my full code:

#![no_main]
#![no_std]

use core::time::Duration;
use log::info;
use uefi::prelude::*;
use uefi::proto::console::gop::GraphicsOutput;
use uefi::allocator::Allocator;

use embedded_graphics_gop::*;
use embedded_graphics::{
    mono_font::{ascii::FONT_6X10, MonoTextStyle},
    pixelcolor::Rgb888,
    prelude::*,
    primitives::{Circle, PrimitiveStyle, Rectangle},
    text::Text,
    text::TextStyleBuilder,
};
use embedded_canvas::*;
use embedded_graphics::text::LineHeight;
use embedded_layout::prelude::*;
use tinybmp::*;


#[global_allocator]
static ALLOCATOR: Allocator = Allocator;


#[entry]
fn main() -> Status {
    uefi::helpers::init().unwrap();
    info!("Hello world!");

    let gop_handle = boot::get_handle_for_protocol::<GraphicsOutput>()
        .expect("Failed to get GOP handle");

    let mut gop = boot::open_protocol_exclusive::<GraphicsOutput>(gop_handle)
        .expect("Failed to open GOP");

    let mut display =  BltDrawTarget::new(&mut gop).unwrap();
    display.double_buffer(true).unwrap();

    
    display.clear(Rgb888::BLACK).unwrap();
    display.commit().unwrap();

    
    Rectangle::new(Point::new(50, 50), Size::new(50, 50))
        .into_styled(PrimitiveStyle::with_stroke(Rgb888::RED, 5))
        .draw(&mut display)
        .unwrap();
    display.commit().unwrap();
    
    Circle::new(Point::new(53, 53), 44)
        .into_styled(PrimitiveStyle::with_fill(Rgb888::BLUE))
        .draw(&mut display)
        .unwrap();
    display.commit().unwrap();
    

    let character_style = MonoTextStyle::new(&FONT_6X10, Rgb888::new(255, 255, 255)); 
    let text_style = TextStyleBuilder::new().line_height(LineHeight::Pixels(50)).build();

    Text::with_text_style(
        "Hello, UEFI!",
        Point::new(50, 150), 
        character_style,
        text_style,
    )
        .draw(&mut display)
        .unwrap();
    display.commit().unwrap();

    let bmp_data = [
        0x42, 0x4D, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28,
        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00,
        0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00,
    ];

    if let Ok(bmp) = Bmp::<Rgb888>::from_slice(&bmp_data) {
        bmp.draw(&mut display.translated(Point::new(50, 150)))
            .unwrap();
    }
    display.commit().unwrap();
    boot::stall(Duration::from_secs(10));
    Status::SUCCESS
}

[rfuest]

I'm not familiar with that the embedded-graphics-gop crate, but there might be an issue with it's DrawTarget implementation. I would suggest to try calling the methods in DrawTarget manually to see if one of them doesn't work as expected (untested example):

let rect = Rectangle::new(Point::new(0, 0), Size::new(100, 100));
display.draw_iter(rect.points().map(|p| Pixel(p, Rgb888::Red)).unwrap();
display.commit().unwrap();

let rect = Rectangle::new(Point::new(150, 0), Size::new(100, 100));
display.fill_contiguous(&rect, core::iter::repeat_n(Rgb888::Green, 100 * 100)).unwrap();
display.commit().unwrap();

let rect = Rectangle::new(Point::new(250, 0), Size::new(100, 100));
display.fill_solid(&rect, Rgb888::Blue).unwrap();
display.commit().unwrap();

The way you draw the BMP file isn't really the intended way of drawing, but I don't think that it should cause this issue. Here is the "correct" way:

// Changed to unwrap to make sure the BMP parser can't silently fail
let bmp = Bmp::<Rgb888>::from_slice(&bmp_data).unwrap();
Image::new(&bmp, Point::new(50, 150)).draw(&mut display).unwrap();

If none of this helps and you cannot get help from the crate author, I can take another look if you provide a ready to run project.

[vengestone-dragoon]

thanks!
im not sure if this worked at all. this is the result:

here is my cargo.toml:

[package]
name = "rustEFI"
version = "0.0.1"
edition = "2024"

[dependencies]
log = "0.4.28"
uefi = {version="0.36.1", features=["panic_handler", "logger"]}
embedded-graphics-gop = {version="0.4.0", features=["default"] }
embedded-graphics = {version="0.8.1", features=["default"] }
embedded-canvas = {version="0.3.2", features=["alloc", "default", "embedded-graphics"] }
embedded-layout = "0.4.2"
tinybmp = "0.6.0"

and here is my modified code with the test you provided:

#![no_main]
#![no_std]

use core::time::Duration;
use log::info;
use uefi::prelude::*;
use uefi::proto::console::gop::GraphicsOutput;
use uefi::allocator::Allocator;

use embedded_graphics_gop::*;
use embedded_graphics::{
    mono_font::{ascii::FONT_6X10, MonoTextStyle},
    pixelcolor::Rgb888,
    prelude::*,
    primitives::{Circle, PrimitiveStyle, Rectangle},
    text::Text,
    text::TextStyleBuilder,
};
use embedded_canvas::*;
use embedded_graphics::image::Image;
use embedded_graphics::text::LineHeight;
use embedded_layout::prelude::*;
use tinybmp::*;


#[global_allocator]
static ALLOCATOR: Allocator = Allocator;


#[entry]
fn main() -> Status {
    uefi::helpers::init().unwrap();
    info!("Hello world!");

    let gop_handle = boot::get_handle_for_protocol::<GraphicsOutput>()
        .expect("Failed to get GOP handle");

    let mut gop = boot::open_protocol_exclusive::<GraphicsOutput>(gop_handle)
        .expect("Failed to open GOP");
    let mode_800x600 = gop
        .modes()
        // one of the standard modes, although some systems may only provide 640×480
        .find(|m| m.info().resolution() == (800, 600))
        .expect("Unable to find 800x600 video mode");
    gop.set_mode(&mode_800x600)
        .expect("Couldn't switch to 800x600 video mode");

    let mut display =  BltDrawTarget::new(&mut gop).unwrap();
    display.double_buffer(true).unwrap();

    
    display.clear(Rgb888::BLACK).unwrap();
    display.commit().unwrap();

    
    Rectangle::new(Point::new(50, 50), Size::new(50, 50))
        .into_styled(PrimitiveStyle::with_stroke(Rgb888::RED, 5))
        .draw(&mut display)
        .unwrap();
    display.commit().unwrap();
    
    Circle::new(Point::new(53, 53), 44)
        .into_styled(PrimitiveStyle::with_fill(Rgb888::BLUE))
        .draw(&mut display)
        .unwrap();
    display.commit().unwrap();

    let rect = Rectangle::new(Point::new(0, 150), Size::new(100, 100));
    display.draw_iter(rect.points().map(|p| Pixel(p, Rgb888::RED))).unwrap();
    display.commit().unwrap();

    let rect = Rectangle::new(Point::new(150, 150), Size::new(100, 100));
    display.fill_contiguous(&rect, core::iter::repeat_n(Rgb888::GREEN, 100 * 100)).unwrap();
    display.commit().unwrap();

    let rect = Rectangle::new(Point::new(250, 150), Size::new(100, 100));
    display.fill_solid(&rect, Rgb888::BLUE).unwrap();
    display.commit().unwrap();
    

    let character_style = MonoTextStyle::new(&FONT_6X10, Rgb888::new(255, 255, 255)); 
    let text_style = TextStyleBuilder::new().line_height(LineHeight::Pixels(50)).build();

    Text::with_text_style(
        "Hello, UEFI!",
        Point::new(50, 400),
        character_style,
        text_style,
    )
        .draw(&mut display)
        .unwrap();
    display.commit().unwrap();

    let bmp_data = [
        0x42, 0x4D, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28,
        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00,
        0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00,
    ];

    let bmp = Bmp::<Rgb888>::from_slice(&bmp_data).unwrap();
    Image::new(&bmp, Point::new(350, 50)).draw(&mut display).unwrap();
    display.commit().unwrap();
    boot::stall(Duration::from_secs(10));
    Status::SUCCESS
}

ill try contacting the crates developer as well.

[rfuest]

I only had time to have a quick look, but it seems like there is a panic in the embedded-graphics-gop crate or one of it's dependencies when the Text is drawn:

If you comment out the Text, the BMP file is drawn as expected:

[rfuest]

With debug assertion enabled the error is an integer overflow during the subtraction in this line: https://git.sr.ht/~nytpu/embedded-graphics-gop/tree/master/item/src/blt.rs#L283 The code there looks wrong, because damage_width and damage_height can never be zero, because all values are unsigned and one is added to the result of the subtraction.

[vengestone-dragoon]

The developer of embedded-graphics-gop confirmed the error, and has made a fix in 0.4.1, which i will try later.

[rfuest]

Seems to work: