Struct Canvas 

pub struct Canvas<'fb> {
    pub aa: bool,
    /* private fields */
}

A clipped drawing surface over a Framebuffer.

Fields

aa: bool

When true, polygon / path fill operations use sub-pixel AA (vertical supersample coverage). Set via Canvas::set_aa.

Implementations

impl<'fb> Canvas<'fb>

pub fn new(fb: &'fb mut Framebuffer) -> Self

Create a canvas over fb with a base clip covering the whole buffer. Anti-aliasing is enabled by default.

pub fn set_aa(&mut self, enabled: bool)

Set whether polygon / path fill operations use sub-pixel AA.

When false, the aa flag passed to fill_polygon_clipped is false, producing aliased edges (faster).

pub fn framebuffer(&self) -> &Framebuffer

Borrow the underlying framebuffer.

pub fn push_clip(&mut self, x: f32, y: f32, w: f32, h: f32)

Push a rectangular clip (intersected with the current clip).

pub fn pop_clip(&mut self)

Pop the most recently pushed clip.

pub fn fill_rect(&mut self, x: f32, y: f32, w: f32, h: f32, color: Color)

Fill an axis-aligned rectangle with a solid colour (no AA; pixel-snapped).

pub fn stroke_rect( &mut self, x: f32, y: f32, w: f32, h: f32, thickness: f32, color: Color, )

Stroke a rectangle outline of the given thickness (drawn inward).

pub fn draw_line(&mut self, x0: f32, y0: f32, x1: f32, y1: f32, color: Color)

Draw a 1-pixel line from (x0, y0) to (x1, y1) using Bresenham’s algorithm (no anti-aliasing).

pub fn fill_circle(&mut self, cx: f32, cy: f32, radius: f32, color: Color)

Fill an anti-aliased circle centred at (cx, cy) with radius.

Coverage is estimated from the signed distance to the circle edge, giving a smooth one-pixel-wide anti-aliased boundary.

pub fn fill_rounded_rect( &mut self, x: f32, y: f32, w: f32, h: f32, radius: f32, color: Color, )

Fill a rounded rectangle with a uniform corner radius and AA edges.

pub fn draw_line_wu(&mut self, x0: f32, y0: f32, x1: f32, y1: f32, color: Color)

Draw an anti-aliased line from (x0, y0) to (x1, y1) using Wu’s algorithm (float pixel coverage).

pub fn draw_line_thick( &mut self, x0: f32, y0: f32, x1: f32, y1: f32, width: f32, color: Color, )

Draw a thick anti-aliased line of the given width using a parallel-offset rectangle polygon fill.

pub fn draw_line_dashed( &mut self, x0: f32, y0: f32, x1: f32, y1: f32, color: Color, pattern: DashPattern, )

Draw a dashed line from (x0, y0) to (x1, y1) using pattern.

Dashes and gaps alternate until the endpoint is reached.

pub fn fill_ellipse(&mut self, cx: f32, cy: f32, rx: f32, ry: f32, color: Color)

Fill an axis-aligned anti-aliased ellipse centred at (cx, cy) with semi-axes rx (horizontal) and ry (vertical).

pub fn fill_rounded_rect_per_corner( &mut self, x: f32, y: f32, w: f32, h: f32, radii: [f32; 4], color: Color, )

Fill a rounded rectangle where each corner may have a different radius.

radii = [top_left, top_right, bottom_right, bottom_left].

pub fn blit_rgba( &mut self, src: SrcImage<'_>, dx: f32, dy: f32, dst_w: u32, dst_h: u32, )

Blit an RGBA source image at destination position (dx, dy) with source-over blending and nearest-neighbour scaling to dst_w × dst_h.

pub fn blit_bilinear( &mut self, src: SrcImage<'_>, dx: f32, dy: f32, dst_w: u32, dst_h: u32, )

Blit an RGBA source image at destination position (dx, dy) with source-over blending and bilinear interpolation scaled to dst_w × dst_h.

pub fn blit_nine_slice( &mut self, src: SrcImage<'_>, dx: f32, dy: f32, dst_w: u32, dst_h: u32, insets: [u32; 4], )

Nine-slice blit: corners are copied unscaled; edges stretch in one axis; centre stretches in both axes.

insets = [top, right, bottom, left] in source pixels.

pub fn fill_path(&mut self, path: &PathData, color: Color)

Fill a oxiui_core::paint::PathData using the current clip. Converts verbs to a soft crate::path::Path.

pub fn stroke_path( &mut self, path: &PathData, style: &StrokeStyle, color: Color, )

Stroke a oxiui_core::paint::PathData using the current clip and stroke style.

pub fn fill_linear_gradient_cmd( &mut self, rect: Rect, start: Point, end: Point, stops: &[GradientStop], )

Fill a rectangle with a linear gradient, respecting the current clip.

pub fn fill_radial_gradient_cmd( &mut self, rect: Rect, center: Point, radius: f32, stops: &[GradientStop], )

Fill a rectangle with a radial gradient, respecting the current clip.

pub fn box_shadow_cmd( &mut self, rect: Rect, offset: Point, blur_radius: f32, color: Color, cache: &mut GaussianCache, )

Draw a box shadow. The shadow composites into the full framebuffer (no clip applied — consistent with the existing box_shadow function).

pub fn draw_quad_bezier( &mut self, p0: (f32, f32), ctrl: (f32, f32), p2: (f32, f32), color: Color, )

Draw a quadratic Bézier curve from p0 via ctrl to p2.

pub fn draw_cubic_bezier( &mut self, p0: (f32, f32), c1: (f32, f32), c2: (f32, f32), p3: (f32, f32), color: Color, )

Draw a cubic Bézier curve from p0 via c1, c2 to p3.