pub struct PixmapMut<'a> { /* private fields */ }
Expand description
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§
source§impl<'a> PixmapMut<'a>
impl<'a> PixmapMut<'a>
sourcepub fn from_bytes(data: &'a mut [u8], width: u32, height: u32) -> Option<Self>
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).
sourcepub fn to_owned(&self) -> Pixmap
pub fn to_owned(&self) -> Pixmap
Creates a new Pixmap
from the current data.
Clones the underlying data.
sourcepub fn pixels_mut(&mut self) -> &mut [PremultipliedColorU8]
pub fn pixels_mut(&mut self) -> &mut [PremultipliedColorU8]
Returns a mutable slice of pixels.
source§impl PixmapMut<'_>
impl PixmapMut<'_>
sourcepub fn fill_rect(
&mut self,
rect: Rect,
paint: &Paint<'_>,
transform: Transform,
mask: Option<&Mask>,
)
pub fn fill_rect( &mut self, rect: Rect, paint: &Paint<'_>, transform: Transform, mask: Option<&Mask>, )
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.
sourcepub fn fill_path(
&mut self,
path: &Path,
paint: &Paint<'_>,
fill_rule: FillRule,
transform: Transform,
mask: Option<&Mask>,
)
pub fn fill_path( &mut self, path: &Path, paint: &Paint<'_>, fill_rule: FillRule, transform: Transform, mask: Option<&Mask>, )
Draws a filled path onto the pixmap.
sourcepub fn stroke_path(
&mut self,
path: &Path,
paint: &Paint<'_>,
stroke: &Stroke,
transform: Transform,
mask: Option<&Mask>,
)
pub fn stroke_path( &mut self, path: &Path, paint: &Paint<'_>, stroke: &Stroke, transform: Transform, mask: Option<&Mask>, )
Strokes a path.
Stroking is implemented using two separate algorithms:
- 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 separatePath
, that can be 2-3x larger then the original path. - 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.
sourcepub fn draw_pixmap(
&mut self,
x: i32,
y: i32,
pixmap: PixmapRef<'_>,
paint: &PixmapPaint,
transform: Transform,
mask: Option<&Mask>,
)
pub fn draw_pixmap( &mut self, x: i32, y: i32, pixmap: PixmapRef<'_>, paint: &PixmapPaint, transform: Transform, mask: Option<&Mask>, )
Draws a Pixmap
on top of the current Pixmap
.
The same as filling a rectangle with a pixmap
pattern.
sourcepub fn apply_mask(&mut self, mask: &Mask)
pub fn apply_mask(&mut self, mask: &Mask)
Applies a masks.
When a Mask
is passed to drawing methods, it will be used to mask-out
content we’re about to draw.
This method masks-out an already drawn content.
It’s not as fast, but can be useful when a mask is not available during drawing.
This method is similar to filling the whole pixmap with an another,
mask-like pixmap using the DestinationOut
blend mode.
Mask
must have the same size as Pixmap
. No transform or offset are allowed.