Struct raqote::DrawTarget

pub struct DrawTarget<Backing = Vec<u32>> {
    width: i32,
    height: i32,
    rasterizer: Rasterizer,
    current_point: Option<Point>,
    first_point: Option<Point>,
    buf: Backing,
    clip_stack: Vec<Clip>,
    layer_stack: Vec<Layer>,
    transform: Transform,
}

The main type used for drawing

Fields

width: i32

height: i32

rasterizer: Rasterizer

current_point: Option<Point>

first_point: Option<Point>

buf: Backing

clip_stack: Vec<Clip>

layer_stack: Vec<Layer>

transform: Transform

Implementations

impl DrawTarget

pub fn new(width: i32, height: i32) -> DrawTarget

pub fn from_vec(width: i32, height: i32, vec: Vec<u32>) -> DrawTarget

Use a previously used vector for the bitmap and extend it to the given size(if needed)

pub fn into_vec(self) -> Vec<u32>

Take ownership of the buffer backing the DrawTarget

impl<Backing: AsRef<[u32]> + AsMut<[u32]>> DrawTarget<Backing>

pub fn from_backing(width: i32, height: i32, buf: Backing) -> Self

Use an existing backing storage for the bitmap

The backing store must be the correct size (width*height elements).

pub fn width(&self) -> i32

pub fn height(&self) -> i32

pub fn set_transform(&mut self, transform: &Transform)

sets a transform that will be applied to all drawing operations

pub fn get_transform(&self) -> &Transform

gets the current transform

fn move_to(&mut self, pt: Point)

fn line_to(&mut self, pt: Point)

fn quad_to(&mut self, cpt: Point, pt: Point)

fn add_quad(&mut self, curve: [Point; 3])

fn cubic_to(&mut self, cpt1: Point, cpt2: Point, pt: Point)

fn close(&mut self)

fn apply_path(&mut self, path: &Path)

pub fn push_clip_rect(&mut self, rect: IntRect)

pub fn pop_clip(&mut self)

pub fn push_clip(&mut self, path: &Path)

fn clip_bounds(&self) -> IntRect

pub fn push_layer(&mut self, opacity: f32)

Pushes a new layer as the drawing target. This is used for implementing group opacity effects.

pub fn push_layer_with_blend(&mut self, opacity: f32, blend: BlendMode)

Pushes a new layer as the drawing target. This is used for implementing group opacity or blend effects.

pub fn pop_layer(&mut self)

Draws the most recently pushed layer to the drawing target with the pushed opacity applied.

pub fn draw_image_with_size_at( &mut self, width: f32, height: f32, x: f32, y: f32, image: &Image<'_>, options: &DrawOptions, )

Draws an image at (x, y) with the size (width, height). This will rescale the image to the destination size.

pub fn draw_image_at( &mut self, x: f32, y: f32, image: &Image<'_>, options: &DrawOptions, )

Draws an image at x, y

pub fn mask(&mut self, src: &Source<'_>, x: i32, y: i32, mask: &Mask)

Draws src through an untransformed mask positioned at x, y in device space

pub fn stroke( &mut self, path: &Path, src: &Source<'_>, style: &StrokeStyle, options: &DrawOptions, )

Strokes path with style and fills the result with src

pub fn fill_rect( &mut self, x: f32, y: f32, width: f32, height: f32, src: &Source<'_>, options: &DrawOptions, )

Fills the rect x, y,, width, height with src. If the result is an integer aligned rectangle performance will be faster than filling a rectangular path.

pub fn fill(&mut self, path: &Path, src: &Source<'_>, options: &DrawOptions)

Fills path with src

pub fn clear(&mut self, solid: SolidSource)

Fills the current clip with the solid color solid

pub fn draw_text( &mut self, font: &Font, point_size: f32, text: &str, start: Point, src: &Source<'_>, options: &DrawOptions, )

pub fn draw_glyphs( &mut self, font: &Font, point_size: f32, ids: &[u32], positions: &[Point], src: &Source<'_>, options: &DrawOptions, )

impl DrawTarget

fn choose_blitter<'a, 'b, 'c>( mask: Option<&[u8]>, clip_stack: &'a Vec<Clip>, blitter_storage: &'b mut ShaderBlitterStorage<'a>, shader: &'a dyn Shader, blend: BlendMode, dest: &'a mut [u32], dest_bounds: IntRect, width: i32, ) -> &'b mut dyn Blitter

impl<Backing: AsRef<[u32]> + AsMut<[u32]>> DrawTarget<Backing>

fn composite( &mut self, src: &Source<'_>, mask: Option<&[u8]>, mask_rect: IntRect, rect: IntRect, blend: BlendMode, alpha: f32, )

mask_rect is in DrawTarget space. i.e size is the size of the mask and origin is the position. you can not render a part of the mask

pub fn composite_surface<F: Fn(&[u32], &mut [u32]), SrcBacking: AsRef<[u32]>>( &mut self, src: &DrawTarget<SrcBacking>, src_rect: IntRect, dst: IntPoint, f: F, )

Draws src_rect of src at dst. The current transform and clip are ignored

pub fn copy_surface<SrcBacking: AsRef<[u32]>>( &mut self, src: &DrawTarget<SrcBacking>, src_rect: IntRect, dst: IntPoint, )

Draws src_rect of src at dst. The current transform and clip are ignored. src_rect is clamped to (0, 0, src.width, src.height).

pub fn blend_surface<SrcBacking: AsRef<[u32]>>( &mut self, src: &DrawTarget<SrcBacking>, src_rect: IntRect, dst: IntPoint, blend: BlendMode, )

Blends src_rect of src at dstusing blend mode. The current transform and clip are ignored. src_rect is clamped to (0, 0, src.width, src.height).

pub fn blend_surface_with_alpha<SrcBacking: AsRef<[u32]>>( &mut self, src: &DrawTarget<SrcBacking>, src_rect: IntRect, dst: IntPoint, alpha: f32, )

Blends src_rect of src at dst using alpha. The current transform and clip are ignored. src_rect is clamped to (0, 0, src.width, src.height).

pub fn get_data(&self) -> &[u32]

Returns a reference to the underlying pixel data

pub fn get_data_mut(&mut self) -> &mut [u32]

Returns a mut reference to the underlying pixel data as ARGB with a representation like: (A << 24) | (R << 16) | (G << 8) | B

pub fn get_data_u8(&self) -> &[u8]

Returns a reference to the underlying pixel data as individual bytes with the order BGRA on little endian.

pub fn get_data_u8_mut(&mut self) -> &mut [u8]

Returns a mut reference to the underlying pixel data as individual bytes with the order BGRA on little endian.

pub fn into_inner(self) -> Backing

Take ownership of the buffer backing the DrawTarget

pub fn write_png<P: AsRef<Path>>(&self, path: P) -> Result<(), EncodingError>

Saves the current pixel to a png file at path