Struct tiny_skia::PixmapMut

pub struct PixmapMut<'a> { /* fields omitted */ }

A container that references mutable premultiplied RGBA pixels.

Can be created from Pixmap or from a user provided data.

The data is not aligned, therefore width == stride.

Implementations

impl<'a> PixmapMut<'a>

pub fn from_bytes(data: &'a mut [u8], width: u32, height: u32) -> Option<Self>

Creates a new PixmapMut from bytes.

The size must be at least size.width() * size.height() * BYTES_PER_PIXEL. Zero size in an error. Width is limited by i32::MAX/4.

The data is assumed to have premultiplied RGBA pixels (byteorder: RGBA).

pub fn to_owned(&self) -> Pixmap

Creates a new Pixmap from the current data.

Clones the underlying data.

pub fn as_ref(&self) -> PixmapRef<'_>

Returns a container that references Pixmap’s data.

pub fn width(&self) -> u32

Returns pixmap’s width.

pub fn height(&self) -> u32

Returns pixmap’s height.

pub fn fill(&mut self, color: Color)

Fills the entire pixmap with a specified color.

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

Returns the mutable internal data.

Byteorder: RGBA

pub fn pixels_mut(&mut self) -> &mut [PremultipliedColorU8]

Returns a mutable slice of pixels.

impl PixmapMut<'_>

pub fn fill_rect(
    &mut self,
    rect: Rect,
    paint: &Paint<'_>,
    transform: Transform,
    clip_mask: Option<&ClipMask>
) -> Option<()>

Draws a filled rectangle onto the pixmap.

This function is usually slower than filling a rectangular path, but it produces better results. Mainly it doesn’t suffer from weird clipping of horizontal/vertical edges.

Used mainly to render a pixmap onto a pixmap.

Returns None when there is nothing to fill or in case of a numeric overflow.

pub fn fill_path(
    &mut self,
    path: &Path,
    paint: &Paint<'_>,
    fill_rule: FillRule,
    transform: Transform,
    clip_mask: Option<&ClipMask>
) -> Option<()>

Draws a filled path onto the pixmap.

Returns None when there is nothing to fill or in case of a numeric overflow.

pub fn stroke_path(
    &mut self,
    path: &Path,
    paint: &Paint<'_>,
    stroke: &Stroke,
    transform: Transform,
    clip_mask: Option<&ClipMask>
) -> Option<()>

Strokes a path.

Stroking is implemented using two separate algorithms:

1. If a stroke width is wider than 1px (after applying the transformation), a path will be converted into a stroked path and then filled using fill_path. Which means that we have to allocate a separate Path, that can be 2-3x larger then the original path.
2. If a stroke width is thinner than 1px (after applying the transformation), we will use hairline stroking, which doesn’t involve a separate path allocation.

Also, if a stroke has a dash array, then path will be converted into a dashed path first and then stroked. Which means a yet another allocation.

pub fn draw_pixmap(
    &mut self,
    x: i32,
    y: i32,
    pixmap: PixmapRef<'_>,
    paint: &PixmapPaint,
    transform: Transform,
    clip_mask: Option<&ClipMask>
) -> Option<()>

Draws a Pixmap on top of the current Pixmap.

We basically filling a rectangle with a pixmap pattern.

Trait Implementations

impl Debug for PixmapMut<'_>

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

Formats the value using the given formatter.

impl<'a> PartialEq<PixmapMut<'a>> for PixmapMut<'a>

fn eq(&self, other: &PixmapMut<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &PixmapMut<'a>) -> bool

This method tests for !=.

impl<'a> StructuralPartialEq for PixmapMut<'a>