Struct bufro::Painter

pub struct Painter { /* fields omitted */ }

Object that manages the window and GPU resources

Implementations

impl Painter

pub async fn new_from_window(
    window: &impl HasRawWindowHandle,
    size: (u32, u32),
    backends: Backends
) -> Self

Create a new painter with the given window

pub fn scale(&mut self, x: f32, y: f32)

Scale the transform by the given factor.

pub fn rotate(&mut self, x: f32)

Rotate the transform by the given angle.

pub fn translate(&mut self, x: f32, y: f32)

Translate the transform by the given vector.

pub fn save(&mut self)

Push the current transform onto the stack.

pub fn restore(&mut self)

Pop the current transform from the stack.

pub fn reset(&mut self)

Reset the transform.

pub fn fill_text(
    &mut self,
    font: &Font,
    text: &str,
    x: f32,
    y: f32,
    size: f32,
    color: Color,
    wrap_limit: Option<usize>
)

Fill the given text. wrap_limit can be used to limit the amount of characters in a line.

pub fn stroke_text(
    &mut self,
    font: &Font,
    text: &str,
    x: f32,
    y: f32,
    size: f32,
    color: Color,
    options: StrokeOptions,
    wrap_limit: Option<usize>
)

Stroke the given text. wrap_limit can be used to limit the amount of characters in a line.

pub fn measure_text(
    font: &Font,
    text: &str,
    size: f32,
    wrap_limit: Option<usize>
) -> f32

pub fn resize(&mut self, new_size: (u32, u32))

Resize the canvas.

pub fn regen(&mut self)

pub fn rectangle(
    &mut self,
    x: f32,
    y: f32,
    width: f32,
    height: f32,
    color: Color
)

Draw a rectangle.

pub fn stroke_path(
    &mut self,
    path_builder: &Path,
    color: Color,
    options: StrokeOptions
)

Stroke the given path

pub fn fill_path(&mut self, path_builder: &Path, color: Color)

Fill the given path

pub fn circle(&mut self, x: f32, y: f32, radius: f32, color: Color)

Fill a cicle.

pub fn get_buffer_info(&self) -> String

Useful for debugging.

pub fn clear(&mut self)

Clear all state & GPU buffers.

pub fn flush(&mut self) -> Result<(), SurfaceError>

Flush the current state to the screen.