Struct FbDbDrawTarget 

pub struct FbDbDrawTarget<'proto> { /* private fields */ }

Available on crate feature alloc only.

A double-buffered framebuffer DrawTarget.

Rudimentary damage tracking is performed to minimize the region that gets copied to the primary buffer.

Any untransferred changes are automatically transferred when the FbDbDrawTarget is dropped.

See the module-level documentation for more information on the framebuffer DrawTargets.

Examples

use embedded_graphics_gop::fb::FbDbDrawTarget;
use uefi::{prelude::*, proto::console::gop::GraphicsOutput};

// Get the first available handle for the GOP.
let handle = boot::get_handle_for_protocol::<GraphicsOutput>().unwrap();
// Open the protocol in exclusive mode (exclusive mode is for applications, other modes are
// intended for drivers)
let mut protocol = boot::open_protocol_exclusive::<GraphicsOutput>(handle).unwrap();
// Configure protocol here if desired, for example
let mode = protocol.modes().find(|m| m.info().resolution() == (800, 600)).unwrap();
protocol.set_mode(&mode).unwrap();

// Create the draw target utilizing the configured protocol.
let mut target = FbDbDrawTarget::new(&mut protocol);

// ...draw on it...

// Transfer changes to the framebuffer
target.commit();

Implementations

impl<'proto> FbDbDrawTarget<'proto>

pub fn new(protocol: &'proto mut ScopedProtocol<GraphicsOutput>) -> Self

Create a new FbDbDrawTarget given a GOP protocol handle.

Fills the framebuffer and backbuffer with black.

Note that one should configure the desired graphics mode for the protocol prior to creating the FbDbDrawTarget.

Panics

Exactly the same as FbDrawTarget::new.

Examples found in repository

examples/double_buffered_framebuffer.rs (line 37)

fn main() -> Status {
	helpers::init().unwrap();

	let handle =
		boot::get_handle_for_protocol::<GraphicsOutput>().expect("Unable to get GOP handle");
	let mut gop =
		boot::open_protocol_exclusive::<GraphicsOutput>(handle).expect("Unable to open GOP handle");

	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 target = FbDbDrawTarget::new(&mut gop);

	let center = Point::new(400, 300);

	let white_fill = PrimitiveStyle::with_fill(Rgb888::WHITE);
	let (red_outline, green_outline, blue_outline) = {
		let base = PrimitiveStyleBuilder::new().stroke_width(10);
		(
			base.stroke_color(Rgb888::RED).build(),
			base.stroke_color(Rgb888::GREEN).build(),
			base.stroke_color(Rgb888::BLUE).build(),
		)
	};

	Circle::with_center(center, 500)
		.into_styled(red_outline)
		.draw(&mut target)
		.expect("infallible");

	Circle::with_center(center, 400)
		.into_styled(green_outline)
		.draw(&mut target)
		.expect("infallible");

	target.commit();

	// Would cover circles
	Rectangle::with_center(Point::new(50, 50), Size::new(700, 500))
		.into_styled(white_fill)
		.draw(&mut target)
		.expect("infallible");

	target.discard_changes();

	Circle::with_center(center, 300)
		.into_styled(blue_outline)
		.draw(&mut target)
		.expect("infallible");

	// should auto-commit
	drop(target);

	boot::stall(Duration::from_secs(10));
	runtime::reset(ResetType::SHUTDOWN, Status::SUCCESS, None);
}

examples/ball_framebuffer.rs (line 37)

fn main() -> Status {
	helpers::init().unwrap();

	let handle =
		boot::get_handle_for_protocol::<GraphicsOutput>().expect("Unable to get GOP handle");
	let mut gop =
		boot::open_protocol_exclusive::<GraphicsOutput>(handle).expect("Unable to open GOP handle");

	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 target = FbDbDrawTarget::new(&mut gop);

	let red_fill = PrimitiveStyle::with_fill(Rgb888::RED);
	let blue_fill = PrimitiveStyle::with_fill(Rgb888::BLUE);

	let mut ball_pos = Point::new(200, 300);
	let mut ball_dir = Point::new(5, 5);
	let ball_size = 10;
	for _ in 0..1000 {
		// Drawing over old position with blue instead of black to leave trail behind and
		// demonstrate more colors
		Rectangle::new(ball_pos, Size::new(ball_size, ball_size))
			.into_styled(blue_fill)
			.draw(&mut target)
			.expect("infallible");

		ball_pos += ball_dir;

		if ball_pos.x <= 0 {
			ball_pos.x = 0;
			ball_dir.x = -ball_dir.x;
		} else if ball_pos.x >= 790 {
			ball_pos.x = 790;
			ball_dir.x = -ball_dir.x;
		}
		if ball_pos.y <= 0 {
			ball_pos.y = 0;
			ball_dir.y = -ball_dir.y;
		} else if ball_pos.y >= 590 {
			ball_pos.y = 590;
			ball_dir.y = -ball_dir.y;
		}

		Circle::new(ball_pos, 10)
			.into_styled(red_fill)
			.draw(&mut target)
			.expect("infallible");

		// In real code would probably want to set up UEFI timer and commit in there?
		target.commit();
		boot::stall(Duration::from_millis(10));
	}

	runtime::reset(ResetType::SHUTDOWN, Status::SUCCESS, None);
}

pub fn commit(&mut self)

Transfer the backbuffer contents to the primary buffer.

Examples found in repository

examples/double_buffered_framebuffer.rs (line 61)

fn main() -> Status {
	helpers::init().unwrap();

	let handle =
		boot::get_handle_for_protocol::<GraphicsOutput>().expect("Unable to get GOP handle");
	let mut gop =
		boot::open_protocol_exclusive::<GraphicsOutput>(handle).expect("Unable to open GOP handle");

	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 target = FbDbDrawTarget::new(&mut gop);

	let center = Point::new(400, 300);

	let white_fill = PrimitiveStyle::with_fill(Rgb888::WHITE);
	let (red_outline, green_outline, blue_outline) = {
		let base = PrimitiveStyleBuilder::new().stroke_width(10);
		(
			base.stroke_color(Rgb888::RED).build(),
			base.stroke_color(Rgb888::GREEN).build(),
			base.stroke_color(Rgb888::BLUE).build(),
		)
	};

	Circle::with_center(center, 500)
		.into_styled(red_outline)
		.draw(&mut target)
		.expect("infallible");

	Circle::with_center(center, 400)
		.into_styled(green_outline)
		.draw(&mut target)
		.expect("infallible");

	target.commit();

	// Would cover circles
	Rectangle::with_center(Point::new(50, 50), Size::new(700, 500))
		.into_styled(white_fill)
		.draw(&mut target)
		.expect("infallible");

	target.discard_changes();

	Circle::with_center(center, 300)
		.into_styled(blue_outline)
		.draw(&mut target)
		.expect("infallible");

	// should auto-commit
	drop(target);

	boot::stall(Duration::from_secs(10));
	runtime::reset(ResetType::SHUTDOWN, Status::SUCCESS, None);
}

examples/ball_framebuffer.rs (line 76)

fn main() -> Status {
	helpers::init().unwrap();

	let handle =
		boot::get_handle_for_protocol::<GraphicsOutput>().expect("Unable to get GOP handle");
	let mut gop =
		boot::open_protocol_exclusive::<GraphicsOutput>(handle).expect("Unable to open GOP handle");

	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 target = FbDbDrawTarget::new(&mut gop);

	let red_fill = PrimitiveStyle::with_fill(Rgb888::RED);
	let blue_fill = PrimitiveStyle::with_fill(Rgb888::BLUE);

	let mut ball_pos = Point::new(200, 300);
	let mut ball_dir = Point::new(5, 5);
	let ball_size = 10;
	for _ in 0..1000 {
		// Drawing over old position with blue instead of black to leave trail behind and
		// demonstrate more colors
		Rectangle::new(ball_pos, Size::new(ball_size, ball_size))
			.into_styled(blue_fill)
			.draw(&mut target)
			.expect("infallible");

		ball_pos += ball_dir;

		if ball_pos.x <= 0 {
			ball_pos.x = 0;
			ball_dir.x = -ball_dir.x;
		} else if ball_pos.x >= 790 {
			ball_pos.x = 790;
			ball_dir.x = -ball_dir.x;
		}
		if ball_pos.y <= 0 {
			ball_pos.y = 0;
			ball_dir.y = -ball_dir.y;
		} else if ball_pos.y >= 590 {
			ball_pos.y = 590;
			ball_dir.y = -ball_dir.y;
		}

		Circle::new(ball_pos, 10)
			.into_styled(red_fill)
			.draw(&mut target)
			.expect("infallible");

		// In real code would probably want to set up UEFI timer and commit in there?
		target.commit();
		boot::stall(Duration::from_millis(10));
	}

	runtime::reset(ResetType::SHUTDOWN, Status::SUCCESS, None);
}

pub fn discard_changes(&mut self)

Discard any uncommitted changes when in double-buffered mode.

The damaged portion of the backbuffer will have its contents overwritten with the current state of the primary buffer, truly discarding any changes since the last commit.

Examples found in repository

examples/double_buffered_framebuffer.rs (line 69)

fn main() -> Status {
	helpers::init().unwrap();

	let handle =
		boot::get_handle_for_protocol::<GraphicsOutput>().expect("Unable to get GOP handle");
	let mut gop =
		boot::open_protocol_exclusive::<GraphicsOutput>(handle).expect("Unable to open GOP handle");

	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 target = FbDbDrawTarget::new(&mut gop);

	let center = Point::new(400, 300);

	let white_fill = PrimitiveStyle::with_fill(Rgb888::WHITE);
	let (red_outline, green_outline, blue_outline) = {
		let base = PrimitiveStyleBuilder::new().stroke_width(10);
		(
			base.stroke_color(Rgb888::RED).build(),
			base.stroke_color(Rgb888::GREEN).build(),
			base.stroke_color(Rgb888::BLUE).build(),
		)
	};

	Circle::with_center(center, 500)
		.into_styled(red_outline)
		.draw(&mut target)
		.expect("infallible");

	Circle::with_center(center, 400)
		.into_styled(green_outline)
		.draw(&mut target)
		.expect("infallible");

	target.commit();

	// Would cover circles
	Rectangle::with_center(Point::new(50, 50), Size::new(700, 500))
		.into_styled(white_fill)
		.draw(&mut target)
		.expect("infallible");

	target.discard_changes();

	Circle::with_center(center, 300)
		.into_styled(blue_outline)
		.draw(&mut target)
		.expect("infallible");

	// should auto-commit
	drop(target);

	boot::stall(Duration::from_secs(10));
	runtime::reset(ResetType::SHUTDOWN, Status::SUCCESS, None);
}

pub fn discard_changes_no_reset(&mut self)

When in double-buffered mode, discard any uncommitted changes without resetting the backbuffer contents.

Note that this leaves the backbuffer untouched but marked as not needing to be transferred. This will make future drawing and committing very inconsistent and should likely only be used to discard changes prior to dropping the FbDbDrawTarget.

impl FbDbDrawTarget<'static>

pub unsafe fn new_free_lifetime( protocol: &mut ScopedProtocol<GraphicsOutput>, ) -> Self

Equivalent to FbDbDrawTarget::new, but allows the FbDrawTarget to outlive the input ScopedProtocol.

See FbDrawTarget::new_free_lifetime for complete usage and safety information.

Trait Implementations

impl<'proto> Debug for FbDbDrawTarget<'proto>

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

Formats the value using the given formatter.

impl DrawTarget for FbDbDrawTarget<'_>

type Color = Rgb888

The pixel color type the targetted display supports.

type Error = Infallible

Error type to return when a drawing operation fails.

fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>

where I: IntoIterator<Item = Pixel<Self::Color>>,

Draw individual pixels to the display without a defined order.

fn fill_solid( &mut self, area: &Rectangle, color: Self::Color, ) -> Result<(), Self::Error>

Fill a given area with a solid color.

fn fill_contiguous<I>( &mut self, area: &Rectangle, colors: I, ) -> Result<(), Self::Error>

where I: IntoIterator<Item = Self::Color>,

Fill a given area with an iterator providing a contiguous stream of pixel colors.

fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error>

Fill the entire display with a solid color.

impl Drop for FbDbDrawTarget<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl OriginDimensions for FbDbDrawTarget<'_>

fn size(&self) -> Size

Returns the size of the bounding box.