Struct skia_safe::RCHandle

impl RCHandle<SkBlender>

pub fn mode(mode: BlendMode) -> Blender

Create a blender that implements the specified BlendMode.

pub fn filter_color4f( &self, color: impl AsRef<Color4f>, src_color_space: &ColorSpace, dst_color_space: Option<&ColorSpace> ) -> Color4f

pub fn composed(&self, inner: impl Into<ColorFilter>) -> Option<Self>

impl RCHandle<SkColorSpace>

pub fn new_srgb() -> Self

pub fn new_srgb_linear() -> Self

pub fn to_xyzd50_hash(&self) -> XYZD50Hash

pub fn with_linear_gamma(&self) -> Self

pub fn with_srgb_gamma(&self) -> Self

pub fn with_color_spin(&self) -> Self

pub fn is_srgb(&self) -> bool

pub fn serialize(&self) -> Data

pub fn deserialize(data: impl Into<Data>) -> Self

impl RCHandle<SkContourMeasure>

pub fn length(&self) -> scalar

pub fn pos_tan(&self, distance: scalar) -> Option<(Point, Vector)>

pub fn get_matrix( &self, distance: scalar, flags: impl Into<Option<MatrixFlags>> ) -> Option<Matrix>

pub fn segment( &self, start_d: scalar, stop_d: scalar, start_with_move_to: bool ) -> Option<Path>

pub fn is_closed(&self) -> bool

impl RCHandle<SkData>

pub fn size(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn as_bytes(&self) -> &[u8] ⓘ

pub fn copy_range(&self, offset: usize, buffer: &mut [u8]) -> &Self

pub fn new_copy(data: &[u8]) -> Self

pub unsafe fn new_bytes(data: &[u8]) -> Self

Constructs Data from a given byte slice without copying it.

Users must make sure that the underlying slice will outlive the lifetime of the Data.

pub unsafe fn new_uninitialized(length: usize) -> Data

pub fn new_zero_initialized(length: usize) -> Data

pub fn new_subset(data: &Data, offset: usize, length: usize) -> Data

pub fn new_str(str: impl AsRef<str>) -> Data

Constructs Data from a copy of a &str.

Functions that use Data as a string container usually expect it to contain a c-string including the terminating 0 byte, so this function converts the Rust str to a CString and calls Self::new_cstr().

pub fn new_cstr(cstr: &CStr) -> Data

Constructs Data from a &CStr by copying its contents.

pub fn new_empty() -> Self

impl RCHandle<SkDataTable>

pub fn is_empty(&self) -> bool

pub fn count(&self) -> usize

pub fn at_size(&self, index: usize) -> usize

pub fn at(&self, index: usize) -> &[u8] ⓘ

pub unsafe fn at_t<T: Copy>(&self, index: usize) -> &[T]

pub fn at_str(&self, index: usize) -> &CStr

pub fn new_empty() -> Self

pub fn from_slices(slices: &[&[u8]]) -> Self

pub fn from_slice<T: Copy>(slice: &[T]) -> Self

pub fn iter(&self) -> Iter<'_> ⓘ

impl RCHandle<SkDrawable>

pub fn draw(&mut self, canvas: &mut Canvas, matrix: Option<&Matrix>)

pub fn draw_at(&mut self, canvas: &mut Canvas, point: impl Into<Point>)

pub fn snap_gpu_draw_handler( &mut self, api: BackendAPI, matrix: &Matrix, clip_bounds: impl Into<IRect>, buffer_info: &ImageInfo ) -> Option<GPUDrawHandler>

pub fn make_picture_snapshot(&mut self) -> Picture

pub fn generation_id(&mut self) -> u32

pub fn bounds(&mut self) -> Rect

pub fn approximate_bytes_used(&mut self) -> usize

pub fn notify_drawing_changed(&mut self)

impl RCHandle<SkFontStyleSet>

pub fn count(&mut self) -> usize

pub fn style(&mut self, index: usize) -> (FontStyle, Option<String>)

pub fn new_typeface(&mut self, index: usize) -> Option<Typeface>

pub fn match_style( &mut self, index: usize, pattern: FontStyle ) -> Option<Typeface>

pub fn new_empty() -> Self

impl RCHandle<SkFontMgr>

pub fn new() -> Self

pub fn empty() -> Self

pub fn count_families(&self) -> usize

pub fn family_name(&self, index: usize) -> String

pub fn family_names(&self) -> impl Iterator<Item = String> + '_

pub fn new_styleset(&self, index: usize) -> FontStyleSet

👎Deprecated since 0.41.0: Use new_style_set

pub fn new_style_set(&self, index: usize) -> FontStyleSet

pub fn match_family(&self, family_name: impl AsRef<str>) -> FontStyleSet

pub fn match_family_style( &self, family_name: impl AsRef<str>, style: FontStyle ) -> Option<Typeface>

pub fn match_family_style_character( &self, family_name: impl AsRef<str>, style: FontStyle, bcp_47: &[&str], character: Unichar ) -> Option<Typeface>

pub fn match_face_style( &self, _typeface: impl AsRef<Typeface>, _style: FontStyle ) -> !

👎Deprecated since 0.35.0: Removed without replacement

pub fn new_from_data( &self, bytes: &[u8], ttc_index: impl Into<Option<usize>> ) -> Option<Typeface>

impl RCHandle<SkImage>

pub fn from_raster_data( info: &ImageInfo, pixels: impl Into<Data>, row_bytes: usize ) -> Option<Image>

👎Deprecated since 0.63.0: use images::raster_from_data()

Creates Image from ImageInfo, sharing pixels.

Image is returned if ImageInfo is valid. Valid ImageInfo parameters include: dimensions are greater than zero; each dimension fits in 29 bits; ColorType and AlphaType are valid, and ColorType is not ColorType::Unknown; rowBytes are large enough to hold one row of pixels; pixels is not nullptr, and contains enough data for Image.

info contains width, height, AlphaType, ColorType, ColorSpace
pixels address or pixel storage
rowBytes size of pixel row or larger Returns: Image sharing pixels, or None

pub fn from_bitmap(bitmap: &Bitmap) -> Option<Image>

👎Deprecated since 0.63.0: use images::raster_from_bitmap()

Creates Image from bitmap, sharing or copying bitmap pixels. If the bitmap is marked immutable, and its pixel memory is shareable, it may be shared instead of copied.

Image is returned if bitmap is valid. Valid Bitmap parameters include: dimensions are greater than zero; each dimension fits in 29 bits; ColorType and AlphaType are valid, and ColorType is not ColorType::Unknown; row bytes are large enough to hold one row of pixels; pixel address is not null.

bitmap ImageInfo, row bytes, and pixels Returns: created Image, or None

example: https://fiddle.skia.org/c/@Image_MakeFromBitmap

pub fn from_generator(image_generator: ImageGenerator) -> Option<Image>

👎Deprecated since 0.63.0: use images::deferred_from_generator()

Creates Image from data returned by image_generator. Generated data is owned by Image and may not be shared or accessed.

Image is returned if generator data is valid. Valid data parameters vary by type of data and platform.

imageGenerator may wrap Picture data, codec data, or custom data.

image_generator stock or custom routines to retrieve Image Returns: created Image, or None

See Self::from_encoded_with_alpha_type()

pub fn from_encoded(data: impl Into<Data>) -> Option<Image>

pub fn from_encoded_with_alpha_type( data: impl Into<Data>, alpha_type: impl Into<Option<AlphaType>> ) -> Option<Image>

Return an image backed by the encoded data, but attempt to defer decoding until the image is actually used/drawn. This deferral allows the system to cache the result, either on the CPU or on the GPU, depending on where the image is drawn. If memory is low, the cache may be purged, causing the next draw of the image to have to re-decode.

If alphaType is None, the image’s alpha type will be chosen automatically based on the image format. Transparent images will default to AlphaType::Premul. If alphaType contains AlphaType::Premul or AlphaType::Unpremul, that alpha type will be used. Forcing opaque (passing AlphaType::Opaque) is not allowed, and will return nullptr.

This is similar to decode_to_{raster,texture}, but this method will attempt to defer the actual decode, while the decode_to… method explicitly decode and allocate the backend when the call is made.

If the encoded format is not supported, None is returned.

encoded the encoded data Returns: created Image, or None

example: https://fiddle.skia.org/c/@Image_MakeFromEncoded

pub fn decode_to_raster(_encoded: &[u8], _subset: impl Into<Option<IRect>>) -> !

👎Deprecated since 0.35.0: Removed without replacement

pub fn new_raster_from_compressed( data: impl Into<Data>, dimensions: impl Into<ISize>, ty: TextureCompressionType ) -> Option<Image>

👎Deprecated since 0.63.0: use images::raster_from_compressed_texture_data()

Creates a CPU-backed Image from compressed data.

This method will decompress the compressed data and create an image wrapping it. Any mipmap levels present in the compressed data are discarded.

data compressed data to store in Image
width width of full Image
height height of full Image
ty type of compression used Returns: created Image, or None

pub fn from_picture( picture: impl Into<Picture>, dimensions: impl Into<ISize>, matrix: Option<&Matrix>, paint: Option<&Paint>, bit_depth: BitDepth, color_space: impl Into<Option<ColorSpace>> ) -> Option<Image>

👎Deprecated since 0.63.0: use images::deferred_from_picture()

See Self::from_picture_with_props()

pub fn from_picture_with_props( picture: impl Into<Picture>, dimensions: impl Into<ISize>, matrix: Option<&Matrix>, paint: Option<&Paint>, bit_depth: BitDepth, color_space: impl Into<Option<ColorSpace>>, props: SurfaceProps ) -> Option<Image>

👎Deprecated since 0.63.0: use images::deferred_from_picture()

Creates Image from picture. Returned Image width and height are set by dimensions. Image draws picture with matrix and paint, set to bitDepth and colorSpace.

If matrix is None, draws with identity Matrix. If paint is None, draws with default Paint. color_space may be None.

picture stream of drawing commands
dimensions width and height
matrix Matrix to rotate, scale, translate, and so on; may be None
paint Paint to apply transparency, filtering, and so on; may be None
bitDepth 8-bit integer or 16-bit float: per component
color_space range of colors; may be None
props props to use when rasterizing the picture Returns: created Image, or None

pub fn new_texture_from_compressed( context: &mut DirectContext, data: Data, dimensions: impl Into<ISize>, ty: TextureCompressionType, mipmapped: impl Into<Option<Mipmapped>>, is_protected: impl Into<Option<Protected>> ) -> Option<Image>

👎Deprecated since 0.63.0: use gpu::images::texture_from_compressed_texture_data()

Creates a GPU-backed Image from compressed data.

This method will return an Image representing the compressed data. If the GPU doesn’t support the specified compression method, the data will be decompressed and then wrapped in a GPU-backed image.

Note: one can query the supported compression formats via gpu::RecordingContext::compressed_backend_format.

context GPU context
data compressed data to store in Image
width width of full Image
height height of full Image
ty type of compression used
mipmapped does ‘data’ contain data for all the mipmap levels?
is_protected do the contents of ‘data’ require DRM protection (on Vulkan)? Returns: created Image, or None

pub fn from_compressed( _context: &mut RecordingContext, _data: Data, _dimensions: impl Into<ISize>, _ct: TextureCompressionType ) -> !

👎Deprecated since 0.35.0: Removed without replacement

pub fn from_texture( context: &mut RecordingContext, backend_texture: &BackendTexture, origin: SurfaceOrigin, color_type: ColorType, alpha_type: AlphaType, color_space: impl Into<Option<ColorSpace>> ) -> Option<Image>

Creates Image from GPU texture associated with context. GPU texture must stay valid and unchanged until texture_release_proc is called. texture_release_proc is passed release_context when Image is deleted or no longer refers to texture.

Image is returned if format of backend_texture is recognized and supported. Recognized formats vary by GPU back-end.

Note: When using a DDL recording context, texture_release_proc will be called on the GPU thread after the DDL is played back on the direct context.

context GPU context
backend_texture Texture residing on GPU
origin Origin of backend_texture
color_type Color type of the resulting image
alpha_type Alpha type of the resulting image
color_space This describes the color space of this image’s contents, as seen after sampling. In general, if the format of the backend texture is SRGB, some linear color_space should be supplied (e.g., ColorSpace::new_srgb_linear())). If the format of the backend texture is linear, then the color_space should include a description of the transfer function as well (e.g., ColorSpace::MakeSRGB).
texture_release_proc Function called when texture can be released
release_context State passed to texture_release_proc Returns: Created Image, or None

pub fn from_pixmap_cross_context( context: &mut DirectContext, pixmap: &Pixmap<'_>, build_mips: bool, limit_to_max_texture_size: impl Into<Option<bool>> ) -> Option<Image>

👎Deprecated since 0.27.0: renamed, use new_cross_context_from_pixmap

pub fn new_cross_context_from_pixmap( context: &mut DirectContext, pixmap: &Pixmap<'_>, build_mips: bool, limit_to_max_texture_size: impl Into<Option<bool>> ) -> Option<Image>

👎Deprecated since 0.63.0: use gpu::images::cross_context_texture_from_pixmap()

Creates Image from pixmap. Image is uploaded to GPU back-end using context.

Created Image is available to other GPU contexts, and is available across thread boundaries. All contexts must be in the same GPU share group, or otherwise share resources.

When Image is no longer referenced, context releases texture memory asynchronously.

ColorSpace of Image is determined by pixmap.color_space().

Image is returned referring to GPU back-end if context is not None, format of data is recognized and supported, and if context supports moving resources between contexts. Otherwise, pixmap pixel data is copied and Image as returned in raster format if possible; None may be returned. Recognized GPU formats vary by platform and GPU back-end.

context GPU context
pixmap ImageInfo, pixel address, and row bytes
build_mips create Image as mip map if true
limit_to_max_texture_size downscale image to GPU maximum texture size, if necessary Returns: created Image, or None

pub fn from_adopted_texture( context: &mut RecordingContext, backend_texture: &BackendTexture, texture_origin: SurfaceOrigin, color_type: ColorType, alpha_type: impl Into<Option<AlphaType>>, color_space: impl Into<Option<ColorSpace>> ) -> Option<Image>

👎Deprecated since 0.63.0: use gpu::images::adopt_texture_from()

Creates Image from backend_texture associated with context. backend_texture and returned Image are managed internally, and are released when no longer needed.

Image is returned if format of backend_texture is recognized and supported. Recognized formats vary by GPU back-end.

context GPU context
backend_texture texture residing on GPU
texture_origin origin of backend_texture
color_type color type of the resulting image
alpha_type alpha type of the resulting image
color_space range of colors; may be None Returns: created Image, or None

pub fn from_yuva_textures( context: &mut RecordingContext, yuva_textures: &YUVABackendTextures, image_color_space: impl Into<Option<ColorSpace>> ) -> Option<Image>

👎Deprecated since 0.63.0: use gpu::images::texture_from_yuva_textures()

Creates an Image from YUV[A] planar textures. This requires that the textures stay valid for the lifetime of the image. The ReleaseContext can be used to know when it is safe to either delete or overwrite the textures. If ReleaseProc is provided it is also called before return on failure.

context GPU context
yuva_textures A set of textures containing YUVA data and a description of the data and transformation to RGBA.
image_color_space range of colors of the resulting image after conversion to RGB; may be None
texture_release_proc called when the backend textures can be released
release_context state passed to texture_release_proc Returns: created Image, or None

pub fn from_yuva_pixmaps( context: &mut RecordingContext, yuva_pixmaps: &YUVAPixmaps, build_mips: impl Into<Option<Mipmapped>>, limit_to_max_texture_size: impl Into<Option<bool>>, image_color_space: impl Into<Option<ColorSpace>> ) -> Option<Image>

👎Deprecated since 0.63.0: use gpu::images::texture_from_yuva_pixmaps()

Creates Image from crate::YUVAPixmaps.

The image will remain planar with each plane converted to a texture using the passed gpu::RecordingContext.

crate::YUVAPixmaps has a crate::YUVAInfo which specifies the transformation from YUV to RGB. The ColorSpace of the resulting RGB values is specified by image_color_space. This will be the ColorSpace reported by the image and when drawn the RGB values will be converted from this space into the destination space (if the destination is tagged).

Currently, this is only supported using the GPU backend and will fail if context is None.

crate::YUVAPixmaps does not need to remain valid after this returns.

context GPU context
pixmaps The planes as pixmaps with supported crate::YUVAInfo that specifies conversion to RGB.
build_mips create internal YUVA textures as mip map if Yes. This is silently ignored if the context does not support mip maps.
limit_to_max_texture_size downscale image to GPU maximum texture size, if necessary
image_color_space range of colors of the resulting image; may be None Returns: created Image, or None

pub fn from_nv12_textures_copy( _context: &mut DirectContext, _yuv_color_space: YUVColorSpace, _nv12_textures: &[BackendTexture; 2], _image_origin: SurfaceOrigin, _image_color_space: impl Into<Option<ColorSpace>> ) -> !

👎Deprecated since 0.37.0: Removed without replacement

pub fn image_info(&self) -> &ImageInfo

Returns a ImageInfo describing the width, height, color type, alpha type, and color space of the Image.

Returns: image info of Image.

pub fn width(&self) -> i32

Returns pixel count in each row.

Returns: pixel width in Image

pub fn height(&self) -> i32

Returns pixel row count.

Returns: pixel height in Image

pub fn dimensions(&self) -> ISize

Returns ISize { width(), height() }.

Returns: integral size of width() and height()

pub fn bounds(&self) -> IRect

Returns IRect { 0, 0, width(), height() }.

Returns: integral rectangle from origin to width() and height()

pub fn unique_id(&self) -> u32

Returns value unique to image. Image contents cannot change after Image is created. Any operation to create a new Image will receive generate a new unique number.

Returns: unique identifier

pub fn alpha_type(&self) -> AlphaType

Returns AlphaType.

AlphaType returned was a parameter to an Image constructor, or was parsed from encoded data.

Returns: AlphaType in Image

example: https://fiddle.skia.org/c/@Image_alphaType

pub fn color_type(&self) -> ColorType

Returns ColorType if known; otherwise, returns ColorType::Unknown.

Returns: ColorType of Image

example: https://fiddle.skia.org/c/@Image_colorType

pub fn color_space(&self) -> ColorSpace

Returns a smart pointer to ColorSpace, the range of colors, associated with Image. The smart pointer tracks the number of objects sharing this ColorSpace reference so the memory is released when the owners destruct.

The returned ColorSpace is immutable.

ColorSpace returned was passed to an Image constructor, or was parsed from encoded data. ColorSpace returned may be ignored when Image is drawn, depending on the capabilities of the crate::Surface receiving the drawing.

Returns: ColorSpace in Image, or None, wrapped in a smart pointer

example: https://fiddle.skia.org/c/@Image_refColorSpace

pub fn is_alpha_only(&self) -> bool

Returns true if Image pixels represent transparency only. If true, each pixel is packed in 8 bits as defined by ColorType::Alpha8.

Returns: true if pixels represent a transparency mask

example: https://fiddle.skia.org/c/@Image_isAlphaOnly

pub fn is_opaque(&self) -> bool

Returns true if pixels ignore their alpha value and are treated as fully opaque.

Returns: true if AlphaType is AlphaType::Opaque

pub fn to_shader<'a>( &self, tile_modes: impl Into<Option<(TileMode, TileMode)>>, sampling: impl Into<SamplingOptions>, local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Shader>

Make a shader with the specified tiling and mipmap sampling.

pub fn to_raw_shader<'a>( &self, tile_modes: impl Into<Option<(TileMode, TileMode)>>, sampling: impl Into<SamplingOptions>, local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Shader>

to_raw_shader functions like to_shader, but for images that contain non-color data. This includes images encoding things like normals, material properties (eg, roughness), heightmaps, or any other purely mathematical data that happens to be stored in an image. These types of images are useful with some programmable shaders (see: crate::RuntimeEffect).

Raw image shaders work like regular image shaders (including filtering and tiling), with a few major differences:

No color space transformation is ever applied (the color space of the image is ignored).
Images with an alpha type of Unpremul are not automatically premultiplied.
Bicubic filtering is not supported. If SamplingOptions::use_cubic is true, these factories will return None.

pub fn peek_pixels(&self) -> Option<Pixmap<'_>>

Copies Image pixel address, row bytes, and ImageInfo to pixmap, if address is available, and returns true. If pixel address is not available, return false and leave pixmap unchanged.

pixmap storage for pixel state if pixels are readable; otherwise, ignored Returns: true if Image has direct access to pixels

example: https://fiddle.skia.org/c/@Image_peekPixels

pub fn is_texture_backed(&self) -> bool

Returns true if the contents of Image was created on or uploaded to GPU memory, and is available as a GPU texture.

Returns: true if Image is a GPU texture

example: https://fiddle.skia.org/c/@Image_isTextureBacked

pub fn texture_size(&self) -> usize

Returns an approximation of the amount of texture memory used by the image. Returns zero if the image is not texture backed or if the texture has an external format.

pub fn is_valid(&self, context: &mut RecordingContext) -> bool

Returns true if Image can be drawn on either raster surface or GPU surface. If context is None, tests if Image draws on raster surface; otherwise, tests if Image draws on GPU surface associated with context.

Image backed by GPU texture may become invalid if associated context is invalid. lazy image may be invalid and may not draw to raster surface or GPU surface or both.

context GPU context Returns: true if Image can be drawn

example: https://fiddle.skia.org/c/@Image_isValid

pub fn flush<'a>( &self, context: &mut DirectContext, flush_info: impl Into<Option<&'a FlushInfo>> ) -> SemaphoresSubmitted

👎Deprecated since 0.63.0: use gpu::DirectContext::flush()

See Self::flush_with_info()

pub fn flush_with_info( &self, context: &mut DirectContext, flush_info: &FlushInfo ) -> SemaphoresSubmitted

👎Deprecated since 0.46.0: use gpu::DirectContext::flush()

Flushes any pending uses of texture-backed images in the GPU backend. If the image is not texture-backed (including promise texture images) or if the gpu::DirectContext does not have the same context ID as the context backing the image then this is a no-op.

If the image was not used in any non-culled draws in the current queue of work for the passed gpu::DirectContext then this is a no-op unless the gpu::FlushInfo contains semaphores or a finish proc. Those are respected even when the image has not been used.

context the context on which to flush pending usages of the image.
info flush options

pub fn flush_and_submit(&self, context: &mut DirectContext)

👎Deprecated since 0.63.0: use gpu::DirectContext::flush_and_submit()

Version of flush() that uses a default gpu::FlushInfo. Also submits the flushed work to the GPU.

pub fn backend_texture( &self, flush_pending_gr_context_io: bool ) -> Option<(BackendTexture, SurfaceOrigin)>

👎Deprecated since 0.63.0: use gpu::images::get_backend_texture_from_image()

Retrieves the back-end texture. If Image has no back-end texture, Noneis returned.

If flush_pending_gr_context_io is true, completes deferred I/O operations.

If origin in not None, copies location of content drawn into Image.

flush_pending_gr_context_io flag to flush outstanding requests Returns: back-end API texture handle; invalid on failure

pub fn read_pixels_with_context<'a, P>( &self, context: impl Into<Option<&'a mut DirectContext>>, dst_info: &ImageInfo, pixels: &mut [P], dst_row_bytes: usize, src: impl Into<IPoint>, caching_hint: CachingHint ) -> bool

Copies crate::Rect of pixels from Image to dst_pixels. Copy starts at offset (src_x, src_y), and does not exceed Image (width(), height()).

dst_info specifies width, height, ColorType, AlphaType, and ColorSpace of destination. dst_row_bytes specifies the gap from one destination row to the next. Returns true if pixels are copied. Returns false if:

dst_info.addr() equals None
dst_row_bytes is less than dst_info.min_row_bytes()
crate::PixelRef is None

Pixels are copied only if pixel conversion is possible. If Image ColorType is ColorType::Gray8, or ColorType::Alpha8; dst_info.color_type() must match. If Image ColorType is ColorType::Gray8, dst_info.color_space() must match. If Image AlphaType is AlphaType::Opaque, dst_info.alpha_type() must match. If Image ColorSpace is None, dst_info.color_space() must match. Returns false if pixel conversion is not possible.

src_x and src_y may be negative to copy only top or left of source. Returns false if width() or height() is zero or negative. Returns false if abs(src_x) >= Image width(), or if abs(src_y) >= Image height().

If caching_hint is CachingHint::Allow, pixels may be retained locally. If caching_hint is CachingHint::Disallow, pixels are not added to the local cache.

context the gpu::DirectContext in play, if it exists
dst_info destination width, height, ColorType, AlphaType, ColorSpace
dst_pixels destination pixel storage
dst_row_bytes destination row length
src_x column index whose absolute value is less than width()
src_y row index whose absolute value is less than height()
caching_hint whether the pixels should be cached locally Returns: true if pixels are copied to dst_pixels

pub fn read_pixels_to_pixmap_with_context<'a>( &self, context: impl Into<Option<&'a mut DirectContext>>, dst: &Pixmap<'_>, src: impl Into<IPoint>, caching_hint: CachingHint ) -> bool

Copies a crate::Rect of pixels from Image to dst. Copy starts at (src_x, src_y), and does not exceed Image (width(), height()).

dst specifies width, height, ColorType, AlphaType, ColorSpace, pixel storage, and row bytes of destination. dst.row_bytes() specifics the gap from one destination row to the next. Returns true if pixels are copied. Returns false if:

dst pixel storage equals None
dst.row_bytes is less than ImageInfo::min_row_bytes
crate::PixelRef is None

Pixels are copied only if pixel conversion is possible. If Image ColorType is ColorType::Gray8, or ColorType::Alpha8; dst.color_type() must match. If Image ColorType is ColorType::Gray8, dst.color_space() must match. If Image AlphaType is AlphaType::Opaque, dst.alpha_type() must match. If Image ColorSpace is None, dst.color_space() must match. Returns false if pixel conversion is not possible.

src_x and src_y may be negative to copy only top or left of source. Returns false if width() or height() is zero or negative. Returns false if abs(src_x) >= Image width(), or if abs(src_y) >= Image height().

If caching_hint is CachingHint::Allow, pixels may be retained locally. If caching_hint is CachingHint::Disallow, pixels are not added to the local cache.

context the gpu::DirectContext in play, if it exists
dst destination Pixmap:ImageInfo, pixels, row bytes
src_x column index whose absolute value is less than width()
src_y row index whose absolute value is less than height()
caching_hint whether the pixels should be cached locally_z Returns: true if pixels are copied to dst

pub fn read_pixels( &self, dst_info: &ImageInfo, pixels: &mut [P], dst_row_bytes: usize, src: impl Into<IPoint>, caching_hint: CachingHint ) -> bool

See Self::read_pixels_with_context()

See Self::read_pixels_to_pixmap_with_context()

pub unsafe fn read_pixels_to_pixmap( &self, dst: &Pixmap<'_>, src: impl Into<IPoint>, caching_hint: CachingHint ) -> bool

pub fn scale_pixels( &self, dst: &Pixmap<'_>, sampling: impl Into<SamplingOptions>, caching_hint: impl Into<Option<CachingHint>> ) -> bool

Copies Image to dst, scaling pixels to fit dst.width() and dst.height(), and converting pixels to match dst.color_type() and dst.alpha_type(). Returns true if pixels are copied. Returns false if dst.addr() is None, or dst.row_bytes() is less than dst ImageInfo::min_row_bytes.

Pixels are copied only if pixel conversion is possible. If Image ColorType is ColorType::Gray8, or ColorType::Alpha8; dst.color_type() must match. If Image ColorType is ColorType::Gray8, dst.color_space() must match. If Image AlphaType is AlphaType::Opaque, dst.alpha_type() must match. If Image ColorSpace is None, dst.color_space() must match. Returns false if pixel conversion is not possible.

If caching_hint is CachingHint::Allow, pixels may be retained locally. If caching_hint is CachingHint::Disallow, pixels are not added to the local cache.

dst destination Pixmap:ImageInfo, pixels, row bytes Returns: true if pixels are scaled to fit dst

pub fn encode_to_data_with_context( &self, context: impl Into<Option<DirectContext>>, image_format: EncodedImageFormat, quality: impl Into<Option<u32>> ) -> Option<Data>

👎Deprecated since 0.63.0: Use encode

Encodes Image pixels, returning result as Data.

Returns None if encoding fails, or if encoded_image_format is not supported.

Image encoding in a format requires both building with one or more of: SK_ENCODE_JPEG, SK_ENCODE_PNG, SK_ENCODE_WEBP; and platform support for the encoded format.

If SK_BUILD_FOR_MAC or SK_BUILD_FOR_IOS is defined, encoded_image_format can additionally be one of: EncodedImageFormat::ICO, EncodedImageFormat::BMP, EncodedImageFormat::GIF.

quality is a platform and format specific metric trading off size and encoding error. When used, quality equaling 100 encodes with the least error. quality may be ignored by the encoder.

context - the gpu::DirectContext in play, if it exists; can be None
encoded_image_format - one of: EncodedImageFormat::JPEG, EncodedImageFormat::PNG, EncodedImageFormat::WEBP
quality - encoder specific metric with 100 equaling best Returns: encoded Image, or None

example: https://fiddle.skia.org/c/@Image_encodeToData

pub fn encode_to_data(&self, image_format: EncodedImageFormat) -> Option<Data>

👎Deprecated since 0.63.0: Support for encoding GPU backed images without a context was removed, use encode_to_data_with_context instead

See Self::encode_to_data_with_quality

pub fn encode_to_data_with_quality( &self, image_format: EncodedImageFormat, quality: u32 ) -> Option<Data>

👎Deprecated since 0.63.0: Support for encoding GPU backed images without a context was removed, use encode_to_data_with_context instead

Encodes Image pixels, returning result as Data.

Returns None if encoding fails, or if encoded_image_format is not supported.

Image encoding in a format requires both building with one or more of: SK_ENCODE_JPEG, SK_ENCODE_PNG, SK_ENCODE_WEBP; and platform support for the encoded format.

If SK_BUILD_FOR_MAC or SK_BUILD_FOR_IOS is defined, encoded_image_format can additionally be one of: EncodedImageFormat::ICO, EncodedImageFormat::BMP, EncodedImageFormat::GIF.

quality is a platform and format specific metric trading off size and encoding error. When used, quality equaling 100 encodes with the least error. quality may be ignored by the encoder.

encoded_image_format one of: EncodedImageFormat::JPEG, EncodedImageFormat::PNG, EncodedImageFormat::WEBP
quality encoder specific metric with 100 equaling best Returns: encoded Image, or None

example: https://fiddle.skia.org/c/@Image_encodeToData

pub fn encoded_data(&self) -> Option<Data>

Returns encoded Image pixels as Data, if Image was created from supported encoded stream format. Platform support for formats vary and may require building with one or more of: SK_ENCODE_JPEG, SK_ENCODE_PNG, SK_ENCODE_WEBP.

Returns None if Image contents are not encoded.

Returns: encoded Image, or None

example: https://fiddle.skia.org/c/@Image_refEncodedData

pub fn new_subset(&self, rect: impl AsRef<IRect>) -> Option<Image>

👎Deprecated since 0.64.0: use make_subset()

See Self::new_subset_with_context

pub fn new_subset_with_context<'a>( &self, rect: impl AsRef<IRect>, direct: impl Into<Option<&'a mut DirectContext>> ) -> Option<Image>

👎Deprecated since 0.64.0: use make_subset()

Returns subset of this image.

Returns None if any of the following are true:

Subset is empty
Subset is not contained inside the image’s bounds
Pixels in the image could not be read or copied

If this image is texture-backed, the context parameter is required and must match the context of the source image. If the context parameter is provided, and the image is raster-backed, the subset will be converted to texture-backed.

subset bounds of returned Image
context the gpu::DirectContext in play, if it exists Returns: the subsetted image, or None

example: https://fiddle.skia.org/c/@Image_makeSubset

pub fn make_subset<'a>( &self, direct: impl Into<Option<&'a mut DirectContext>>, subset: impl AsRef<IRect> ) -> Option<Image>

Returns subset of this image.

Returns None if any of the following are true: - Subset is empty - Subset is not contained inside the image’s bounds - Pixels in the source image could not be read or copied - This image is texture-backed and the provided context is null or does not match the source image’s context.

If the source image was texture-backed, the resulting image will be texture-backed also. Otherwise, the returned image will be raster-backed.

direct - the gpu::DirectContext of the source image (None is ok if the source image is not texture-backed).
subset - bounds of returned Image Returns: the subsetted image, or None

example: https://fiddle.skia.org/c/@Image_makeSubset

pub fn has_mipmaps(&self) -> bool

Returns true if the image has mipmap levels.

pub fn with_default_mipmaps(&self) -> Option<Image>

Returns an image with the same “base” pixels as the this image, but with mipmap levels automatically generated and attached.

pub fn new_texture_image( &self, context: &mut DirectContext, mipmapped: Mipmapped ) -> Option<Image>

See Self::new_texture_image_budgeted

pub fn new_texture_image_budgeted( &self, direct_context: &mut DirectContext, mipmapped: Mipmapped, budgeted: Budgeted ) -> Option<Image>

Returns Image backed by GPU texture associated with context. Returned Image is compatible with crate::Surface created with dst_color_space. The returned Image respects mipmapped setting; if mipmapped equals gpu::Mipmapped::Yes, the backing texture allocates mip map levels.

The mipmapped parameter is effectively treated as No if MIP maps are not supported by the GPU.

Returns original Image if the image is already texture-backed, the context matches, and mipmapped is compatible with the backing GPU texture. crate::Budgeted is ignored in this case.

Returns None if context is None, or if Image was created with another gpu::DirectContext.

direct_context the gpu::DirectContext in play, if it exists
mipmapped whether created Image texture must allocate mip map levels
budgeted whether to count a newly created texture for the returned image counts against the context’s budget. Returns: created Image, or None

pub fn to_non_texture_image(&self) -> Option<Image>

👎Deprecated since 0.64.0: use make_non_texture_image()

Returns raster image or lazy image. Copies Image backed by GPU texture into CPU memory if needed. Returns original Image if decoded in raster bitmap, or if encoded in a stream.

Returns None if backed by GPU texture and copy fails.

Returns: raster image, lazy image, or None

example: https://fiddle.skia.org/c/@Image_makeNonTextureImage

pub fn make_non_texture_image<'a>( &self, context: impl Into<Option<&'a mut DirectContext>> ) -> Option<Image>

Returns raster image or lazy image. Copies Image backed by GPU texture into CPU memory if needed. Returns original Image if decoded in raster bitmap, or if encoded in a stream.

Returns None if backed by GPU texture and copy fails.

Returns: raster image, lazy image, or None

example: https://fiddle.skia.org/c/@Image_makeNonTextureImage

pub fn to_raster_image( &self, caching_hint: impl Into<Option<CachingHint>> ) -> Option<Image>

👎Deprecated since 0.64.0: use make_raster_image()

Returns raster image. Copies Image backed by GPU texture into CPU memory, or decodes Image from lazy image. Returns original Image if decoded in raster bitmap.

Returns None if copy, decode, or pixel read fails.

If caching_hint is CachingHint::Allow, pixels may be retained locally. If caching_hint is CachingHint::Disallow, pixels are not added to the local cache.

Returns: raster image, or None

example: https://fiddle.skia.org/c/@Image_makeRasterImage

pub fn make_raster_image<'a>( &self, context: impl Into<Option<&'a mut DirectContext>>, caching_hint: impl Into<Option<CachingHint>> ) -> Option<Image>

Returns raster image. Copies Image backed by GPU texture into CPU memory, or decodes Image from lazy image. Returns original Image if decoded in raster bitmap.

Returns None if copy, decode, or pixel read fails.

If caching_hint is CachingHint::Allow, pixels may be retained locally. If caching_hint is CachingHint::Disallow, pixels are not added to the local cache.

Returns: raster image, or None

example: https://fiddle.skia.org/c/@Image_makeRasterImage

pub fn new_with_filter( &self, context: Option<&mut RecordingContext>, filter: &ImageFilter, clip_bounds: impl Into<IRect>, subset: impl Into<IRect> ) -> Option<(Image, IRect, IPoint)>

Creates filtered Image. filter processes original Image, potentially changing color, position, and size. subset is the bounds of original Image processed by filter. clip_bounds is the expected bounds of the filtered Image. out_subset is required storage for the actual bounds of the filtered Image. offset is required storage for translation of returned Image.

Returns None if Image could not be created or if the recording context provided doesn’t match the GPU context in which the image was created. If None is returned, out_subset and offset are undefined.

Useful for animation of ImageFilter that varies size from frame to frame. Returned Image is created larger than required by filter so that GPU texture can be reused with different sized effects. out_subset describes the valid bounds of GPU texture returned. offset translates the returned Image to keep subsequent animation frames aligned with respect to each other.

context the gpu::RecordingContext in play - if it exists
filter how Image is sampled when transformed
subset bounds of Image processed by filter
clip_bounds expected bounds of filtered Image
out_subset storage for returned Image bounds
offset storage for returned Image translation Returns: filtered Image, or None

pub fn is_lazy_generated(&self) -> bool

Returns true if Image is backed by an image-generator or other service that creates and caches its pixels or texture on-demand.

Returns: true if Image is created as needed

example: https://fiddle.skia.org/c/@Image_isLazyGenerated_a example: https://fiddle.skia.org/c/@Image_isLazyGenerated_b

See Self::new_color_space_with_context

pub fn new_color_space( &self, color_space: impl Into<Option<ColorSpace>> ) -> Option<Image>

👎Deprecated since 0.64.0: use make_color_space()

pub fn new_color_space_with_context<'a>( &self, color_space: impl Into<Option<ColorSpace>>, direct: impl Into<Option<&'a mut DirectContext>> ) -> Option<Image>

👎Deprecated since 0.64.0: use make_color_space()

Creates Image in target ColorSpace. Returns None if Image could not be created.

Returns original Image if it is in target ColorSpace. Otherwise, converts pixels from Image ColorSpace to target ColorSpace. If Image color_space() returns None, Image ColorSpace is assumed to be s_rgb.

If this image is texture-backed, the context parameter is required and must match the context of the source image.

target ColorSpace describing color range of returned Image
direct The gpu::DirectContext in play, if it exists Returns: created Image in target ColorSpace

example: https://fiddle.skia.org/c/@Image_makeColorSpace

pub fn make_color_space<'a>( &self, direct: impl Into<Option<&'a mut DirectContext>>, color_space: impl Into<Option<ColorSpace>> ) -> Option<Image>

Creates Image in target ColorSpace. Returns None if Image could not be created.

Returns original Image if it is in target ColorSpace. Otherwise, converts pixels from Image ColorSpace to target ColorSpace. If Image color_space() returns None, Image ColorSpace is assumed to be s_rgb.

If this image is texture-backed, the context parameter is required and must match the context of the source image.

direct The gpu::DirectContext in play, if it exists
target ColorSpace describing color range of returned Image Returns: created Image in target ColorSpace

example: https://fiddle.skia.org/c/@Image_makeColorSpace

pub fn reinterpret_color_space( &self, new_color_space: impl Into<ColorSpace> ) -> Option<Image>

Creates a new Image identical to this one, but with a different ColorSpace. This does not convert the underlying pixel data, so the resulting image will draw differently.

impl RCHandle<SkImageFilter>

pub fn filter_bounds<'a>( &self, src: impl AsRef<IRect>, ctm: &Matrix, map_direction: MapDirection, input_rect: impl Into<Option<&'a IRect>> ) -> IRect

pub fn color_filter_node(&self) -> Option<ColorFilter>

pub fn to_a_color_filter(&self) -> Option<ColorFilter>

pub fn count_inputs(&self) -> usize

pub fn input(&self, i: usize) -> Option<ImageFilter>

👎Deprecated: use get_input()

pub fn get_input(&self, i: usize) -> Option<ImageFilter>

pub fn inputs(&self) -> impl Iterator<Item = Option<ImageFilter>> + '_

pub fn compute_fast_bounds(&self, bounds: impl AsRef<Rect>) -> Rect

pub fn can_compute_fast_bounds(&self) -> bool

pub fn with_local_matrix(&self, matrix: &Matrix) -> Option<ImageFilter>

impl RCHandle<SkMaskFilter>

pub fn blur( style: BlurStyle, sigma: scalar, respect_ctm: impl Into<Option<bool>> ) -> Option<Self>

Create a blur mask filter.

style The BlurStyle to use
sigma Standard deviation of the Gaussian blur to apply. Must be > 0.
respect_ctm if true the blur’s sigma is modified by the ctm. Returns the new blur mask filter

pub fn approximate_filtered_bounds(&self, src: impl AsRef<Rect>) -> Rect

Returns the approximate bounds that would result from filtering the src rect. The actual result may be different, but it should be contained within the returned bounds.

pub fn compose(_outer: Self, _inner: Self) -> !

👎Deprecated since 0.30.0: removed without replacement

pub fn combine(_filter_a: Self, _filter_b: Self, _mode: CoverageMode) -> !

👎Deprecated since 0.30.0: removed without replacement

pub fn with_matrix(&self, _matrix: &Matrix) -> !

👎Deprecated since 0.29.0: removed without replacement

impl RCHandle<SkPathEffect>

pub fn sum( first: impl Into<PathEffect>, second: impl Into<PathEffect> ) -> PathEffect

pub fn compose( first: impl Into<PathEffect>, second: impl Into<PathEffect> ) -> PathEffect

pub fn as_a_dash(&self) -> Option<DashInfo>

pub fn filter_path( &self, src: &Path, stroke_rec: &StrokeRec, cull_rect: impl AsRef<Rect> ) -> Option<(Path, StrokeRec)>

pub fn filter_path_inplace( &self, dst: &mut Path, src: &Path, stroke_rec: &mut StrokeRec, cull_rect: impl AsRef<Rect> ) -> bool

pub fn filter_path_inplace_with_matrix( &self, dst: &mut Path, src: &Path, stroke_rec: &mut StrokeRec, cull_rect: impl AsRef<Rect>, ctm: &Matrix ) -> bool

pub fn needs_ctm(&self) -> bool

impl RCHandle<SkPicture>

pub fn from_data(data: &Data) -> Option<Picture>

pub fn from_bytes(bytes: &[u8]) -> Option<Picture>

pub fn playback(&self, canvas: &mut Canvas)

pub fn cull_rect(&self) -> Rect

pub fn unique_id(&self) -> u32

pub fn serialize(&self) -> Data

pub fn new_placeholder(cull: impl AsRef<Rect>) -> Picture

pub fn approximate_op_count(&self) -> usize

pub fn approximate_op_count_nested( &self, nested: impl Into<Option<bool>> ) -> usize

pub fn approximate_bytes_used(&self) -> usize

pub fn to_shader<'a, 'b>( &self, tm: impl Into<Option<(TileMode, TileMode)>>, mode: FilterMode, local_matrix: impl Into<Option<&'a Matrix>>, tile_rect: impl Into<Option<&'b Rect>> ) -> Shader

impl RCHandle<SkPixelRef>

pub fn dimensions(&self) -> ISize

pub fn width(&self) -> i32

pub fn height(&self) -> i32

pub unsafe fn pixels(&self) -> *mut c_void

pub fn row_bytes(&self) -> usize

pub fn generation_id(&self) -> u32

pub fn notify_pixels_changed(&mut self)

pub fn is_immutable(&self) -> bool

pub fn set_immutable(&mut self)

pub fn notify_added_to_cache(&mut self)

impl RCHandle<SkShader>

pub fn is_opaque(&self) -> bool

pub fn image(&self) -> Option<(Image, Matrix, (TileMode, TileMode))>

pub fn is_a_image(&self) -> bool

pub fn with_local_matrix(&self, matrix: &Matrix) -> Self

pub fn with_color_filter(&self, color_filter: impl Into<ColorFilter>) -> Self

impl RCHandle<SkSurface>

pub fn new_raster_direct<'pixels>( image_info: &ImageInfo, pixels: &'pixels mut [u8], row_bytes: impl Into<Option<usize>>, surface_props: Option<&SurfaceProps> ) -> Option<Borrows<'pixels, Surface>>

👎Deprecated since 0.64.0: use surfaces::wrap_pixels()

Allocates raster Surface. Canvas returned by Surface draws directly into pixels.

Surface is returned if all parameters are valid. Valid parameters include: info dimensions are greater than zero; info contains crate::ColorType and crate::AlphaType supported by raster surface; pixels is not None; row_bytes is large enough to contain info width pixels of crate::ColorType.

Pixel buffer size should be info height times computed row_bytes. Pixels are not initialized. To access pixels after drawing, Self::peek_pixels() or Self::read_pixels().

image_info - width, height, crate::ColorType, crate::AlphaType, crate::ColorSpace, of raster surface; width and height must be greater than zero
pixels - pointer to destination pixels buffer
row_bytes - interval from one Surface row to the next
surface_props - LCD striping orientation and setting for device independent fonts; may be None Returns: Surface if all parameters are valid; otherwise, None

pub fn new_raster( image_info: &ImageInfo, row_bytes: impl Into<Option<usize>>, surface_props: Option<&SurfaceProps> ) -> Option<Self>

👎Deprecated since 0.64.0: use surfaces::raster()

Allocates raster Surface. Canvas returned by Surface draws directly into pixels. Allocates and zeroes pixel memory. Pixel memory size is image_info.height() times row_bytes, or times image_info.min_row_bytes() if row_bytes is zero. Pixel memory is deleted when Surface is deleted.

Surface is returned if all parameters are valid. Valid parameters include: info dimensions are greater than zero; info contains crate::ColorType and crate::AlphaType supported by raster surface; row_bytes is large enough to contain info width pixels of crate::ColorType, or is zero.

If row_bytes is zero, a suitable value will be chosen internally.

image_info - width, height, crate::ColorType, crate::AlphaType, crate::ColorSpace, of raster surface; width and height must be greater than zero
row_bytes - interval from one Surface row to the next; may be zero
surface_props - LCD striping orientation and setting for device independent fonts; may be None Returns: Surface if all parameters are valid; otherwise, None

pub fn new_raster_n32_premul(size: impl Into<ISize>) -> Option<Self>

👎Deprecated since 0.64.0: use surfaces::raster_n32_premul()

Allocates raster Surface. Canvas returned by Surface draws directly into pixels. Allocates and zeroes pixel memory. Pixel memory size is height times width times four. Pixel memory is deleted when Surface is deleted.

Internally, sets ImageInfo to width, height, native color type, and crate::AlphaType::Premul.

Surface is returned if width and height are greater than zero.

Use to create Surface that matches crate::PMColor, the native pixel arrangement on the platform. Surface drawn to output device skips converting its pixel format.

width - pixel column count; must be greater than zero
height - pixel row count; must be greater than zero
surface_props - LCD striping orientation and setting for device independent fonts; may be None Returns: Surface if all parameters are valid; otherwise, None

impl RCHandle<SkSurface>

pub fn from_backend_texture( context: &mut RecordingContext, backend_texture: &BackendTexture, origin: SurfaceOrigin, sample_cnt: impl Into<Option<usize>>, color_type: ColorType, color_space: impl Into<Option<ColorSpace>>, surface_props: Option<&SurfaceProps> ) -> Option<Self>

👎Deprecated since 0.64.0: use gpu::surfaces::wrap_backend_texture()

Wraps a GPU-backed texture into Surface. Caller must ensure the texture is valid for the lifetime of returned Surface. If sample_cnt greater than zero, creates an intermediate MSAA Surface which is used for drawing backend_texture.

Surface is returned if all parameters are valid. backend_texture is valid if its pixel configuration agrees with color_space and context; for instance, if backend_texture has an sRGB configuration, then context must support sRGB, and color_space must be present. Further, backend_texture width and height must not exceed context capabilities, and the context must be able to support back-end textures.

context - GPU context
backend_texture - texture residing on GPU
sample_cnt - samples per pixel, or 0 to disable full scene anti-aliasing
color_space - range of colors; may be None
surface_props - LCD striping orientation and setting for device independent fonts; may be None Returns: Surface if all parameters are valid; otherwise, None

pub fn from_backend_render_target( context: &mut RecordingContext, backend_render_target: &BackendRenderTarget, origin: SurfaceOrigin, color_type: ColorType, color_space: impl Into<Option<ColorSpace>>, surface_props: Option<&SurfaceProps> ) -> Option<Self>

👎Deprecated since 0.64.0: use gpu::surfaces::wrap_backend_render_target()

Wraps a GPU-backed buffer into Surface. Caller must ensure backend_render_target is valid for the lifetime of returned Surface.

Surface is returned if all parameters are valid. backend_render_target is valid if its pixel configuration agrees with color_space and context; for instance, if backend_render_target has an sRGB configuration, then context must support sRGB, and color_space must be present. Further, backend_render_target width and height must not exceed context capabilities, and the context must be able to support back-end render targets.

context - GPU context
backend_render_target - GPU intermediate memory buffer
color_space - range of colors
surface_props - LCD striping orientation and setting for device independent fonts; may be None Returns: Surface if all parameters are valid; otherwise, None

pub fn new_render_target( context: &mut RecordingContext, budgeted: Budgeted, image_info: &ImageInfo, sample_count: impl Into<Option<usize>>, surface_origin: impl Into<Option<SurfaceOrigin>>, surface_props: Option<&SurfaceProps>, should_create_with_mips: impl Into<Option<bool>> ) -> Option<Self>

👎Deprecated since 0.64.0: use gpu::surfaces::render_target()

Returns Surface on GPU indicated by context. Allocates memory for pixels, based on the width, height, and crate::ColorType in ImageInfo. budgeted selects whether allocation for pixels is tracked by context. image_info describes the pixel format in crate::ColorType, and transparency in crate::AlphaType, and color matching in crate::ColorSpace.

sample_count requests the number of samples per pixel. Pass zero to disable multi-sample anti-aliasing. The request is rounded up to the next supported count, or rounded down if it is larger than the maximum supported count.

surface_origin pins either the top-left or the bottom-left corner to the origin.

should_create_with_mips hints that Image returned by Image::image_snapshot is mip map.

context - GPU context
image_info - width, height, crate::ColorType, crate::AlphaType, crate::ColorSpace; width, or height, or both, may be zero
sample_count - samples per pixel, or 0 to disable full scene anti-aliasing
surface_props - LCD striping orientation and setting for device independent fonts; may be None
should_create_with_mips - hint that Surface will host mip map images Returns: Surface if all parameters are valid; otherwise, None

pub fn new_render_target_with_characterization( context: &mut RecordingContext, characterization: &SurfaceCharacterization, budgeted: Budgeted ) -> Option<Self>

👎Deprecated since 0.64.0: use gpu::surfaces::render_target_with_characterization()

Returns Surface on GPU indicated by context that is compatible with the provided characterization. budgeted selects whether allocation for pixels is tracked by context.

context - GPU context
characterization - description of the desired Surface Returns: Surface if all parameters are valid; otherwise, None

impl RCHandle<SkSurface>

pub fn is_compatible(&self, characterization: &SurfaceCharacterization) -> bool

Is this surface compatible with the provided characterization?

This method can be used to determine if an existing Surface is a viable destination for an DeferredDisplayList.

characterization - The characterization for which a compatibility check is desired Returns: true if this surface is compatible with the characterization; false otherwise

pub fn new_null(size: impl Into<ISize>) -> Option<Self>

👎Deprecated since 0.64.0: use surfaces::null()

Returns Surface without backing pixels. Drawing to Canvas returned from Surface has no effect. Calling Self::image_snapshot() on returned Surface returns None.

width - one or greater
height - one or greater Returns: Surface if width and height are positive; otherwise, None

example: https://fiddle.skia.org/c/@Surface_MakeNull

pub fn width(&self) -> i32

Returns pixel count in each row; may be zero or greater.

Returns: number of pixel columns

pub fn height(&self) -> i32

Returns pixel row count; may be zero or greater.

Returns: number of pixel rows

pub fn image_info(&mut self) -> ImageInfo

Returns an ImageInfo describing the surface.

pub fn generation_id(&mut self) -> u32

Returns unique value identifying the content of Surface. Returned value changes each time the content changes. Content is changed by drawing, or by calling Self::notify_content_will_change().

Returns: unique content identifier

example: https://fiddle.skia.org/c/@Surface_notifyContentWillChange

pub fn notify_content_will_change( &mut self, mode: ContentChangeMode ) -> &mut Self

Notifies that Surface contents will be changed by code outside of Skia. Subsequent calls to Self::generation_id() return a different value.

example: https://fiddle.skia.org/c/@Surface_notifyContentWillChange

impl RCHandle<SkSurface>

pub fn recording_context(&self) -> Option<RecordingContext>

Returns the recording context being used by the Surface.

Returns: the recording context, if available; None otherwise

pub fn direct_context(&self) -> Option<DirectContext>

rust-skia helper, not in Skia

pub fn get_backend_texture( &mut self, handle_access: BackendHandleAccess ) -> Option<BackendTexture>

👎Deprecated since 0.64.0: use gpu::surfaces::get_backend_texture()

Retrieves the back-end texture. If Surface has no back-end texture, None is returned.

The returned gpu::BackendTexture should be discarded if the Surface is drawn to or deleted.

Returns: GPU texture reference; None on failure

pub fn get_backend_render_target( &mut self, handle_access: BackendHandleAccess ) -> Option<BackendRenderTarget>

👎Deprecated since 0.64.0: use gpu::surfaces::get_backend_render_target()

Retrieves the back-end render target. If Surface has no back-end render target, None is returned.

The returned gpu::BackendRenderTarget should be discarded if the Surface is drawn to or deleted.

Returns: GPU render target reference; None on failure

pub fn replace_backend_texture( &mut self, backend_texture: &BackendTexture, origin: SurfaceOrigin ) -> bool

If the surface was made via Self::from_backend_texture then it’s backing texture may be substituted with a different texture. The contents of the previous backing texture are copied into the new texture. Canvas state is preserved. The original sample count is used. The gpu::BackendFormat and dimensions of replacement texture must match that of the original.

backend_texture - the new backing texture for the surface

pub fn replace_backend_texture_with_mode( &mut self, backend_texture: &BackendTexture, origin: SurfaceOrigin, mode: impl Into<Option<ContentChangeMode>> ) -> bool

If the surface was made via Self::from_backend_texture() then it’s backing texture may be substituted with a different texture. The contents of the previous backing texture are copied into the new texture. Canvas state is preserved. The original sample count is used. The gpu::BackendFormat and dimensions of replacement texture must match that of the original.

backend_texture - the new backing texture for the surface
mode - Retain or discard current Content

impl RCHandle<SkSurface>

pub fn canvas(&mut self) -> &mut Canvas

Returns Canvas that draws into Surface. Subsequent calls return the same Canvas. Canvas returned is managed and owned by Surface, and is deleted when Surface is deleted.

Returns: drawing Canvas for Surface

example: https://fiddle.skia.org/c/@Surface_getCanvas

pub fn new_surface(&mut self, image_info: &ImageInfo) -> Option<Self>

Returns a compatible Surface, or None. Returned Surface contains the same raster, GPU, or null properties as the original. Returned Surface does not share the same pixels.

Returns None if image_info width or height are zero, or if image_info is incompatible with Surface.

image_info - width, height, crate::ColorType, crate::AlphaType, crate::ColorSpace, of Surface; width and height must be greater than zero Returns: compatible Surface or None

example: https://fiddle.skia.org/c/@Surface_makeSurface

pub fn new_surface_with_dimensions( &mut self, dim: impl Into<ISize> ) -> Option<Self>

Calls Self::new_surface() with the same ImageInfo as this surface, but with the specified width and height.

pub fn image_snapshot(&mut self) -> Image

Returns Image capturing Surface contents. Subsequent drawing to Surface contents are not captured. Image allocation is accounted for if Surface was created with gpu::Budgeted::Yes.

Returns: Image initialized with Surface contents

example: https://fiddle.skia.org/c/@Surface_makeImageSnapshot

pub fn image_snapshot_with_bounds( &mut self, bounds: impl AsRef<IRect> ) -> Option<Image>

Like the no-parameter version, this returns an image of the current surface contents. This variant takes a rectangle specifying the subset of the surface that is of interest. These bounds will be sanitized before being used.

If bounds extends beyond the surface, it will be trimmed to just the intersection of it and the surface.
If bounds does not intersect the surface, then this returns None.
If bounds == the surface, then this is the same as calling the no-parameter variant.

example: https://fiddle.skia.org/c/@Surface_makeImageSnapshot_2

pub fn draw( &mut self, canvas: &mut Canvas, offset: impl Into<Point>, sampling: impl Into<SamplingOptions>, paint: Option<&Paint> )

Draws Surface contents to canvas, with its top-left corner at (offset.x, offset.y).

If Paint paint is not None, apply crate::ColorFilter, alpha, crate::ImageFilter, and crate::BlendMode.

canvas - Canvas drawn into
offset.x - horizontal offset in Canvas
offset.y - vertical offset in Canvas
sampling - what technique to use when sampling the surface pixels
paint - Paint containing crate::BlendMode, crate::ColorFilter, crate::ImageFilter, and so on; or None

example: https://fiddle.skia.org/c/@Surface_draw

pub fn peek_pixels(&mut self) -> Option<Pixmap<'_>>

pub fn read_pixels_to_pixmap( &mut self, dst: &Pixmap<'_>, src: impl Into<IPoint> ) -> bool

Copies crate::Rect of pixels to dst.

Source crate::Rect corners are (src.x, src.y) and Surface (width(), height()). Destination crate::Rect corners are (0, 0) and (dst.width(), dst.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to dst_color_type() and dst_alpha_type() if required.

Pixels are readable when Surface is raster, or backed by a GPU.

The destination pixel storage must be allocated by the caller.

Pixel values are converted only if crate::ColorType and crate::AlphaType do not match. Only pixels within both source and destination rectangles are copied. dst contents outside crate::Rect intersection are unchanged.

Pass negative values for src.x or src.y to offset pixels across or down destination.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.
Pixmap pixels could not be allocated.
dst.row_bytes() is too small to contain one row of pixels.

dst - storage for pixels copied from Surface
src_x - offset into readable pixels on x-axis; may be negative
src_y - offset into readable pixels on y-axis; may be negative Returns: true if pixels were copied

example: https://fiddle.skia.org/c/@Surface_readPixels

pub fn read_pixels( &mut self, dst_info: &ImageInfo, dst_pixels: &mut [u8], dst_row_bytes: usize, src: impl Into<IPoint> ) -> bool

Copies crate::Rect of pixels from Canvas into dst_pixels.

Source crate::Rect corners are (src.x, src.y) and Surface (width(), height()). Destination crate::Rect corners are (0, 0) and (dst_info.width(), dst_info.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to dst_info_color_type() and dst_info_alpha_type() if required.

Pixels are readable when Surface is raster, or backed by a GPU.

The destination pixel storage must be allocated by the caller.

Pixel values are converted only if crate::ColorType and crate::AlphaType do not match. Only pixels within both source and destination rectangles are copied. dst_pixels contents outside crate::Rect intersection are unchanged.

Pass negative values for src.x or src.y to offset pixels across or down destination.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.
Surface pixels could not be converted to dst_info.color_type() or dst_info.alpha_type().
dst_row_bytes is too small to contain one row of pixels.

dst_info - width, height, crate::ColorType, and crate::AlphaType of dst_pixels
dst_pixels - storage for pixels; dst_info.height() times dst_row_bytes, or larger
dst_row_bytes - size of one destination row; dst_info.width() times pixel size, or larger
src.x - offset into readable pixels on x-axis; may be negative
src.y - offset into readable pixels on y-axis; may be negative Returns: true if pixels were copied

pub fn read_pixels_to_bitmap( &mut self, bitmap: &Bitmap, src: impl Into<IPoint> ) -> bool

Copies crate::Rect of pixels from Surface into bitmap.

Source crate::Rect corners are (src.x, src.y) and Surface (width(), height()). Destination crate::Rect corners are (0, 0) and (bitmap.width(), bitmap.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to bitmap.color_type() and bitmap.alpha_type() if required.

Pixels are readable when Surface is raster, or backed by a GPU.

The destination pixel storage must be allocated by the caller.

Pixel values are converted only if crate::ColorType and crate::AlphaType do not match. Only pixels within both source and destination rectangles are copied. dst contents outside crate::Rect intersection are unchanged.

Pass negative values for src.x or src.y to offset pixels across or down destination.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.
Surface pixels could not be converted to dst.color_type() or dst.alpha_type().
dst pixels could not be allocated.
dst.row_bytes() is too small to contain one row of pixels.

dst - storage for pixels copied from Surface
src.x - offset into readable pixels on x-axis; may be negative
src.y - offset into readable pixels on y-axis; may be negative Returns: true if pixels were copied

example: https://fiddle.skia.org/c/@Surface_readPixels_3

pub fn write_pixels_from_pixmap( &mut self, src: &Pixmap<'_>, dst: impl Into<IPoint> )

Copies crate::Rect of pixels from the src Pixmap to the Surface.

Source crate::Rect corners are (0, 0) and (src.width(), src.height()). Destination crate::Rect corners are (dst.x, dst.y) and (dst.x + Surface width(), dst.y + Surface height()).

Copies each readable pixel intersecting both rectangles, without scaling, converting to Surface color_type() and Surface alpha_type() if required.

src - storage for pixels to copy to Surface
dst.x - x-axis position relative to Surface to begin copy; may be negative
dst.y - y-axis position relative to Surface to begin copy; may be negative

example: https://fiddle.skia.org/c/@Surface_writePixels

pub fn write_pixels_from_bitmap( &mut self, bitmap: &Bitmap, dst: impl Into<IPoint> )

Copies crate::Rect of pixels from the src Bitmap to the Surface.

Source crate::Rect corners are (0, 0) and (src.width(), src.height()). Destination crate::Rect corners are (dst.x, dst.y) and (dst.x+ Surface width(),dst.y + Surface height()).

Copies each readable pixel intersecting both rectangles, without scaling, converting to Surface color_type() and Surface alpha_type() if required.

src - storage for pixels to copy to Surface
dst.x - x-axis position relative to Surface to begin copy; may be negative
dst.y - y-axis position relative to Surface to begin copy; may be negative

example: https://fiddle.skia.org/c/@Surface_writePixels_2

pub fn props(&self) -> &SurfaceProps

Returns SurfaceProps for surface.

Returns: LCD striping orientation and setting for device independent fonts

pub fn flush_and_submit(&mut self)

Call to ensure all reads/writes of the surface have been issued to the underlying 3D API. Skia will correctly order its own draws and pixel operations. This must to be used to ensure correct ordering when the surface backing store is accessed outside Skia (e.g. direct use of the 3D API or a windowing system). gpu::DirectContext has additional flush and submit methods that apply to all surfaces and images created from a gpu::DirectContext. This is equivalent to calling Self::flush() with a default gpu::FlushInfo followed by gpu::DirectContext::submit.

pub fn flush_submit_and_sync_cpu(&mut self)

See Self::flush_and_submit().

pub fn resolve_msaa(&mut self)

If a surface is GPU texture backed, is being drawn with MSAA, and there is a resolve texture, this call will insert a resolve command into the stream of gpu commands. In order for the resolve to actually have an effect, the work still needs to be flushed and submitted to the GPU after recording the resolve command. If a resolve is not supported or the Surface has no dirty work to resolve, then this call is a no-op.

This call is most useful when the Surface is created by wrapping a single sampled gpu texture, but asking Skia to render with MSAA. If the client wants to use the wrapped texture outside of Skia, the only way to trigger a resolve is either to call this command or use Self::flush().

pub fn flush(&mut self)

See Self::flush_with_mutable_state().

pub fn flush_with_access_info( &mut self, access: BackendSurfaceAccess, info: &FlushInfo ) -> SemaphoresSubmitted

Issues pending Surface commands to the GPU-backed API objects and resolves any Surface MSAA. A call to gpu::DirectContext::submit is always required to ensure work is actually sent to the gpu. Some specific API details: GL: Commands are actually sent to the driver, but gl_flush is never called. Thus some sync objects from the flush will not be valid until a submission occurs.

Vulkan/Metal/D3D/Dawn: Commands are recorded to the backend APIs corresponding command
    buffer or encoder objects. However, these objects are not sent to the gpu until a
    submission occurs.

The work that is submitted to the GPU will be dependent on the BackendSurfaceAccess that is passed in.

If BackendSurfaceAccess::NoAccess is passed in all commands will be issued to the GPU.

If BackendSurfaceAccess::Present is passed in and the backend API is not Vulkan, it is treated the same as k_no_access. If the backend API is Vulkan, the VkImage that backs the Surface will be transferred back to its original queue. If the Surface was created by wrapping a VkImage, the queue will be set to the queue which was originally passed in on the [gpu::vk::ImageInfo]. Additionally, if the original queue was not external or foreign the layout of the VkImage will be set to VK_IMAGE_LAYOUT_PRESENT_SRC_KHR.

The gpu::FlushInfo describes additional options to flush. Please see documentation at gpu::FlushInfo for more info.

If the return is gpu::SemaphoresSubmitted::Yes, only initialized BackendSemaphores will be submitted to the gpu during the next submit call (it is possible Skia failed to create a subset of the semaphores). The client should not wait on these semaphores until after submit has been called, but must keep them alive until then. If a submit flag was passed in with the flush these valid semaphores can we waited on immediately. If this call returns gpu::SemaphoresSubmitted::No, the GPU backend will not submit any semaphores to be signaled on the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in with the gpu::FlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the client is still responsible for deleting any initialized semaphores. Regardless of semaphore submission the context will still be flushed. It should be emphasized that a return value of gpu::SemaphoresSubmitted::No does not mean the flush did not happen. It simply means there were no semaphores submitted to the GPU. A caller should only take this as a failure if they passed in semaphores to be submitted.

Pending surface commands are flushed regardless of the return result.

access - type of access the call will do on the backend object after flush
info - flush options

pub fn flush_with_mutable_state<'a>( &mut self, info: &FlushInfo, new_state: impl Into<Option<&'a MutableTextureState>> ) -> SemaphoresSubmitted

Issues pending Surface commands to the GPU-backed API objects and resolves any Surface MSAA. A call to gpu::DirectContext::submit is always required to ensure work is actually sent to the gpu. Some specific API details: GL: Commands are actually sent to the driver, but gl_flush is never called. Thus some sync objects from the flush will not be valid until a submission occurs.

Vulkan/Metal/D3D/Dawn: Commands are recorded to the backend APIs corresponding command
    buffer or encoder objects. However, these objects are not sent to the gpu until a
    submission occurs.

The gpu::FlushInfo describes additional options to flush. Please see documentation at gpu::FlushInfo for more info.

If a gpu::MutableTextureState is passed in, at the end of the flush we will transition the surface to be in the state requested by the skgpu::MutableTextureState. If the surface (or Image or BackendSurface wrapping the same backend object) is used again after this flush the state may be changed and no longer match what is requested here. This is often used if the surface will be used for presenting or external use and the client wants backend object to be prepped for that use. A finished_proc or semaphore on the gpu::FlushInfo will also include the work for any requested state change.

If the backend API is Vulkan, the caller can set the skgpu::MutableTextureState’s VkImageLayout to VK_IMAGE_LAYOUT_UNDEFINED or queue_family_index to VK_QUEUE_FAMILY_IGNORED to tell Skia to not change those respective states.

If the return is gpu::SemaphoresSubmitted::Yes, only initialized BackendSemaphores will be submitted to the gpu during the next submit call (it is possible Skia failed to create a subset of the semaphores). The client should not wait on these semaphores until after submit has been called, but must keep them alive until then. If a submit flag was passed in with the flush these valid semaphores can we waited on immediately. If this call returns gpu::SemaphoresSubmitted::No, the GPU backend will not submit any semaphores to be signaled on the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in with the gpu::FlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the client is still responsible for deleting any initialized semaphores. Regardless of semaphore submission the context will still be flushed. It should be emphasized that a return value of gpu::SemaphoresSubmitted::No does not mean the flush did not happen. It simply means there were no semaphores submitted to the GPU. A caller should only take this as a failure if they passed in semaphores to be submitted.

Pending surface commands are flushed regardless of the return result.

info - flush options
access - optional state change request after flush

pub fn characterize(&self) -> Option<SurfaceCharacterization>

Initializes SurfaceCharacterization that can be used to perform GPU back-end processing in a separate thread. Typically this is used to divide drawing into multiple tiles. crate::DeferredDisplayListRecorder records the drawing commands for each tile.

Return true if Surface supports characterization. raster surface returns false.

characterization - properties for parallel drawing Returns: true if supported

example: https://fiddle.skia.org/c/@Surface_characterize

pub fn draw_display_list_with_offset( &mut self, deferred_display_list: impl Into<DeferredDisplayList>, offset: impl Into<IVector> ) -> bool

Draws the deferred display list created via a crate::DeferredDisplayListRecorder. If the deferred display list is not compatible with this Surface, the draw is skipped and false is return.

The offset.x and offset.y parameters are experimental and, if not both zero, will cause the draw to be ignored. When implemented, if offset.x or offset.y are non-zero, the DDL will be drawn offset by that amount into the surface.

deferred_display_list - drawing commands
offset.x - x-offset at which to draw the DDL
offset.y - y-offset at which to draw the DDL Returns: false if deferred_display_list is not compatible

example: https://fiddle.skia.org/c/@Surface_draw_2

pub fn draw_display_list( &mut self, deferred_display_list: impl Into<DeferredDisplayList> ) -> bool

See Self::draw_display_list_with_offset.

impl RCHandle<SkTextBlob>

pub fn new(str: impl AsRef<str>, font: &Font) -> Option<Self>

pub fn bounds(&self) -> &Rect

pub fn unique_id(&self) -> u32

pub fn get_intercepts( &self, bounds: [scalar; 2], paint: Option<&Paint> ) -> Vec<scalar>

pub fn from_str(str: impl AsRef<str>, font: &Font) -> Option<TextBlob>

pub fn from_text( text: &[u8], encoding: TextEncoding, font: &Font ) -> Option<TextBlob>

pub fn from_pos_text_h( text: &[u8], x_pos: &[scalar], const_y: scalar, font: &Font, encoding: impl Into<Option<TextEncoding>> ) -> Option<TextBlob>

pub fn from_pos_text( text: &[u8], pos: &[Point], font: &Font, encoding: impl Into<Option<TextEncoding>> ) -> Option<TextBlob>

pub fn from_rsxform( text: &[u8], xform: &[RSXform], font: &Font, encoding: impl Into<Option<TextEncoding>> ) -> Option<TextBlob>

impl RCHandle<SkTypeface>

pub fn new(family_name: impl AsRef<str>, font_style: FontStyle) -> Option<Self>

pub fn font_style(&self) -> FontStyle

pub fn is_bold(&self) -> bool

pub fn is_italic(&self) -> bool

pub fn is_fixed_pitch(&self) -> bool

pub fn variation_design_position(&self) -> Option<Vec<Coordinate>>

pub fn variation_design_parameters(&self) -> Option<Vec<VariationAxis>>

pub fn unique_id(&self) -> TypefaceId

pub fn equal(face_a: impl AsRef<Typeface>, face_b: impl AsRef<Typeface>) -> bool

pub fn from_name( family_name: impl AsRef<str>, font_style: FontStyle ) -> Option<Typeface>

pub fn from_data( data: impl Into<Data>, index: impl Into<Option<usize>> ) -> Option<Typeface>

pub fn clone_with_arguments( &self, arguments: &FontArguments<'_, '_> ) -> Option<Typeface>

pub fn serialize(&self, behavior: SerializeBehavior) -> Data

pub fn deserialize(data: &[u8]) -> Option<Typeface>

pub fn unichars_to_glyphs(&self, uni: &[Unichar], glyphs: &mut [GlyphId])

pub fn str_to_glyphs( &self, str: impl AsRef<str>, glyphs: &mut [GlyphId] ) -> usize

pub fn text_to_glyphs<C>( &self, text: &[C], encoding: TextEncoding, glyphs: &mut [GlyphId] ) -> usize

pub fn unichar_to_glyph(&self, unichar: Unichar) -> GlyphId

pub fn count_glyphs(&self) -> usize

pub fn count_tables(&self) -> usize

pub fn table_tags(&self) -> Option<Vec<FontTableTag>>

pub fn get_table_size(&self, tag: FontTableTag) -> Option<usize>

pub fn get_table_data(&self, tag: FontTableTag, data: &mut [u8]) -> usize

pub fn copy_table_data(&self, tag: FontTableTag) -> Option<Data>

pub fn units_per_em(&self) -> Option<i32>

pub fn get_kerning_pair_adjustments( &self, glyphs: &[GlyphId], adjustments: &mut [i32] ) -> bool

pub fn new_family_name_iterator(&self) -> impl Iterator<Item = LocalizedString>

pub fn family_name(&self) -> String

pub fn post_script_name(&self) -> Option<String>

pub fn to_font_data(&self) -> Option<(Vec<u8>, usize)>

pub fn bounds(&self) -> Rect

impl RCHandle<SkVertices>

pub fn new_copy( mode: VertexMode, positions: &[Point], texs: &[Point], colors: &[Color], indices: Option<&[u16]> ) -> Vertices

pub const MAX_CUSTOM_ATTRIBUTES: usize = 8usize

pub fn unique_id(&self) -> u32

pub fn mode(&self) -> VertexMode

👎Deprecated since 0.29.0: will be removed without replacement

pub fn bounds(&self) -> &Rect

pub fn has_colors(&self) -> bool

👎Deprecated since 0.29.0: will be removed without replacement

pub fn has_tex_coords(&self) -> bool

👎Deprecated since 0.29.0: will be removed without replacement

pub fn has_bones(&self) -> bool

👎Deprecated since 0.29.0: returns false

pub fn has_indices(&self) -> bool

👎Deprecated since 0.29.0: will be removed without replacement

pub fn vertex_count(&self) -> usize

👎Deprecated since 0.29.0: will be removed without replacement

pub fn index_count(&self) -> usize

👎Deprecated since 0.29.0: will be removed without replacement

pub fn positions(&self) -> &[Point]

👎Deprecated since 0.29.0: will be removed without replacement

pub fn tex_coords(&self) -> Option<&[Point]>

👎Deprecated since 0.29.0: will be removed without replacement

pub fn colors(&self) -> Option<&[Color]>

👎Deprecated since 0.29.0: will be removed without replacement

pub fn bone_indices(&self) -> Option<&[BoneIndices]>

👎Deprecated since 0.29.0: returns None

pub fn bone_weights(&self) -> Option<&[BoneWeights]>

👎Deprecated since 0.29.0: returns None

pub fn indices(&self) -> Option<&[u16]>

👎Deprecated since 0.29.0: will be removed without replacement

pub fn is_volatile(&self) -> bool

👎Deprecated since 0.29.0: returns false

pub fn apply_bones(&self, _bones: &[Bone]) -> !

👎Deprecated since 0.29.0: removed without replacement

pub fn approximate_size(&self) -> usize

pub fn decode(_buffer: &[u8]) -> !

👎Deprecated since 0.31.0: removed without replacement

pub fn encode(&self) -> !

👎Deprecated since 0.31.0: removed without replacement

impl RCHandle<SkPathEffect>

pub fn path_1d( path: &Path, advance: scalar, phase: scalar, style: Style ) -> Option<PathEffect>

impl RCHandle<SkPathEffect>

pub fn line_2d(width: scalar, matrix: &Matrix) -> Option<PathEffect>

pub fn path_2d(matrix: &Matrix, path: &Path) -> PathEffect

impl RCHandle<SkBlender>

pub fn arithmetic( k1: f32, k2: f32, k3: f32, k4: f32, enforce_premul: bool ) -> Option<Blender>

impl RCHandle<SkColorFilter>

pub fn new_lighting( mul: impl Into<Color>, add: impl Into<Color> ) -> Option<Self>

👎Deprecated since 0.56.0: Use color_filters::lighting()

impl RCHandle<SkPathEffect>

pub fn corner_path(radius: scalar) -> Option<Self>

impl RCHandle<SkPathEffect>

pub fn dash(intervals: &[scalar], phase: scalar) -> Option<Self>

impl RCHandle<SkPathEffect>

pub fn discrete( seg_length: scalar, dev: scalar, seed_assist: impl Into<Option<u32>> ) -> Option<Self>

impl RCHandle<SkShader>

pub fn linear_gradient<'a>( points: (impl Into<Point>, impl Into<Point>), colors: impl Into<GradientShaderColors<'a>>, pos: impl Into<Option<&'a [scalar]>>, mode: TileMode, flags: impl Into<Option<Flags>>, local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Self>

pub fn linear_gradient_with_interpolation<'a>( points: (impl Into<Point>, impl Into<Point>), colors: (&[Color4f], impl Into<Option<ColorSpace>>), pos: impl Into<Option<&'a [scalar]>>, mode: TileMode, interpolation: impl Into<Interpolation>, local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Self>

pub fn radial_gradient<'a>( center: impl Into<Point>, radius: scalar, colors: impl Into<GradientShaderColors<'a>>, pos: impl Into<Option<&'a [scalar]>>, mode: TileMode, flags: impl Into<Option<Flags>>, local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Self>

pub fn radial_gradient_with_interpolation<'a>( center_and_radius: (impl Into<Point>, scalar), colors: (&[Color4f], impl Into<Option<ColorSpace>>), pos: impl Into<Option<&'a [scalar]>>, mode: TileMode, interpolation: impl Into<Interpolation>, local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Shader>

pub fn two_point_conical_gradient<'a>( start: impl Into<Point>, start_radius: scalar, end: impl Into<Point>, end_radius: scalar, colors: impl Into<GradientShaderColors<'a>>, pos: impl Into<Option<&'a [scalar]>>, mode: TileMode, flags: impl Into<Option<Flags>>, local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Self>

pub fn two_point_conical_gradient_with_interpolation<'a>( start_and_radius: (impl Into<Point>, scalar), end_and_radius: (impl Into<Point>, scalar), colors: (&[Color4f], impl Into<Option<ColorSpace>>), pos: impl Into<Option<&'a [scalar]>>, mode: TileMode, interpolation: impl Into<Interpolation>, local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Shader>

pub fn sweep_gradient<'a>( center: impl Into<Point>, colors: impl Into<GradientShaderColors<'a>>, pos: impl Into<Option<&'a [scalar]>>, mode: TileMode, angles: impl Into<Option<(scalar, scalar)>>, flags: impl Into<Option<Flags>>, local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Self>

pub fn sweep_gradient_with_interpolation<'a>( center: impl Into<Point>, colors: (&[Color4f], impl Into<Option<ColorSpace>>), pos: impl Into<Option<&'a [scalar]>>, mode: TileMode, angles: impl Into<Option<(scalar, scalar)>>, interpolation: impl Into<Interpolation>, local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Shader>

impl RCHandle<SkColorFilter>

pub fn high_contrast(config: &HighContrastConfig) -> Option<Self>

impl RCHandle<SkImageFilter>

pub fn alpha_threshold<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, region: &Region, inner_min: scalar, outer_max: scalar ) -> Option<Self>

pub fn arithmetic<'a>( inputs: impl Into<ArithmeticFPInputs>, background: impl Into<Option<Self>>, foreground: impl Into<Option<Self>>, crop_rect: impl Into<Option<&'a IRect>> ) -> Option<Self>

pub fn blur<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, sigma: (scalar, scalar), tile_mode: impl Into<Option<TileMode>> ) -> Option<Self>

pub fn color_filter<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, cf: impl Into<ColorFilter> ) -> Option<Self>

pub fn compose( outer: impl Into<ImageFilter>, inner: impl Into<ImageFilter> ) -> Option<Self>

pub fn displacement_map_effect<'a>( channel_selectors: (ColorChannel, ColorChannel), scale: scalar, displacement: impl Into<ImageFilter>, color: impl Into<ImageFilter>, crop_rect: impl Into<Option<&'a IRect>> ) -> Option<Self>

pub fn distant_lit_diffuse_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, direction: impl Into<Point3>, light_color: impl Into<Color>, surface_scale: scalar, kd: scalar ) -> Option<Self>

pub fn point_lit_diffuse_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, location: impl Into<Point3>, light_color: impl Into<Color>, surface_scale: scalar, kd: scalar ) -> Option<Self>

pub fn spot_lit_diffuse_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, location: impl Into<Point3>, target: impl Into<Point3>, specular_exponent: scalar, cutoff_angle: scalar, light_color: impl Into<Color>, surface_scale: scalar, kd: scalar ) -> Option<Self>

pub fn distant_lit_specular_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, direction: impl Into<Point3>, light_color: impl Into<Color>, surface_scale: scalar, ks: scalar, shininess: scalar ) -> Option<Self>

pub fn point_lit_specular_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, location: impl Into<Point3>, light_color: impl Into<Color>, surface_scale: scalar, ks: scalar, shininess: scalar ) -> Option<Self>

pub fn spot_lit_specular_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, location: impl Into<Point3>, target: impl Into<Point3>, specular_exponent: scalar, cutoff_angle: scalar, light_color: impl Into<Color>, surface_scale: scalar, ks: scalar, shininess: scalar ) -> Option<Self>

pub fn magnifier<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, src_rect: impl AsRef<Rect>, inset: scalar ) -> Option<Self>

👎Deprecated since 0.64.0: use magnifier2() instead

pub fn magnifier2<'a>( self, lens_bounds: impl AsRef<Rect>, zoom_amount: scalar, inset: scalar, sampling_options: SamplingOptions, crop_rect: impl Into<Option<&'a IRect>> ) -> Option<Self>

pub fn matrix_convolution<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, kernel_size: impl Into<ISize>, kernel: &[scalar], gain: scalar, bias: scalar, kernel_offset: impl Into<IPoint>, tile_mode: TileMode, convolve_alpha: bool ) -> Option<Self>

pub fn merge<'a>( filters: impl IntoIterator<Item = Option<Self>>, crop_rect: impl Into<Option<&'a IRect>> ) -> Option<Self>

pub fn dilate<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, radii: (scalar, scalar) ) -> Option<Self>

pub fn erode<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, radii: (scalar, scalar) ) -> Option<Self>

pub fn offset<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, delta: impl Into<Vector> ) -> Option<Self>

pub fn from_picture<'a>( picture: impl Into<Picture>, crop_rect: impl Into<Option<&'a Rect>> ) -> Option<Self>

pub fn tile(self, src: impl AsRef<Rect>, dst: impl AsRef<Rect>) -> Option<Self>

impl RCHandle<SkPicture>

pub fn as_image_filter<'a>( &self, crop_rect: impl Into<Option<&'a Rect>> ) -> Option<ImageFilter>

pub fn into_image_filter<'a>( self, crop_rect: impl Into<Option<&'a Rect>> ) -> Option<ImageFilter>

impl RCHandle<SkColorFilter>

pub fn luma() -> Self

impl RCHandle<SkPathEffect>

pub fn merge( one: impl Into<PathEffect>, two: impl Into<PathEffect>, op: PathOp ) -> PathEffect

impl RCHandle<SkPathEffect>

pub fn matrix_translate(d: impl Into<Vector>) -> Option<PathEffect>

pub fn matrix(matrix: &Matrix) -> Option<PathEffect>

impl RCHandle<SkPathEffect>

pub fn stroke( width: scalar, join: Join, cap: Cap, miter: impl Into<Option<scalar>> ) -> Option<PathEffect>

impl RCHandle<SkColorFilter>

pub fn overdraw(colors: &[Color; 6]) -> ColorFilter

impl RCHandle<SkShader>

pub fn fractal_perlin_noise( base_frequency: (scalar, scalar), num_octaves: usize, seed: scalar, tile_size: impl Into<Option<ISize>> ) -> Option<Self>

pub fn turbulence_perlin_noise( base_frequency: (scalar, scalar), num_octaves: usize, seed: scalar, tile_size: impl Into<Option<ISize>> ) -> Option<Self>

impl RCHandle<SkRuntimeEffect>

pub fn make_for_color_filer<'a>( sksl: impl AsRef<str>, options: impl Into<Option<&'a Options>> ) -> Result<RuntimeEffect, String>

pub fn make_for_shader<'a>( sksl: impl AsRef<str>, options: impl Into<Option<&'a Options>> ) -> Result<RuntimeEffect, String>

pub fn make_for_blender<'a>( sksl: impl AsRef<str>, options: impl Into<Option<&'a Options>> ) -> Result<RuntimeEffect, String>

pub fn make_shader<'a>( &self, uniforms: impl Into<Data>, children: &[ChildPtr], local_matrix: impl Into<Option<&'a Matrix>> ) -> Option<Shader>

pub fn make_image<'a>( &self, context: &mut RecordingContext, uniforms: impl Into<Data>, children: impl Into<Option<&'a [ChildPtr]>>, local_matrix: impl Into<Option<&'a Matrix>>, result_info: ImageInfo, mipmapped: bool ) -> Option<Image>

pub fn make_color_filter<'a>( &self, inputs: impl Into<Data>, children: impl Into<Option<&'a [ChildPtr]>> ) -> Option<ColorFilter>

pub fn make_blender<'a>( &self, uniforms: impl Into<Data>, children: impl Into<Option<&'a [ChildPtr]>> ) -> Option<Blender>

pub fn source(&self) -> &str

pub fn input_size(&self) -> usize

👎Deprecated since 0.35.0: Use uniform_size() instead

pub fn uniform_size(&self) -> usize

pub fn inputs(&self) -> &[Uniform]

👎Deprecated since 0.35.0: Use uniforms() instead

pub fn uniforms(&self) -> &[Uniform]

pub fn children(&self) -> &[Child]

pub fn find_input(&self, name: impl AsRef<str>) -> Option<&Uniform>

👎Deprecated since 0.35.0: Use find_uniform()

pub fn find_uniform(&self, name: impl AsRef<str>) -> Option<&Uniform>

pub fn find_child(&self, name: impl AsRef<str>) -> Option<&Child>

pub fn allow_shader(&self) -> bool

pub fn allow_color_filter(&self) -> bool

pub fn allow_blender(&self) -> bool

impl RCHandle<SkMaskFilter>

pub fn from_shader(shader: impl Into<Shader>) -> MaskFilter

impl RCHandle<SkColorFilter>

pub fn from_table(table: &[u8; 256]) -> Self

👎Deprecated since 0.56.0: Use color_filters::table()

pub fn from_argb( table_a: Option<&[u8; 256]>, table_r: Option<&[u8; 256]>, table_g: Option<&[u8; 256]>, table_b: Option<&[u8; 256]> ) -> Self

👎Deprecated since 0.56.0: Use color_filters::table_argb()

impl RCHandle<SkPathEffect>

pub fn trim( start_t: scalar, stop_t: scalar, mode: impl Into<Option<Mode>> ) -> Option<PathEffect>

impl RCHandle<SkImage>

pub fn encode<'a>( &self, context: impl Into<Option<&'a mut DirectContext>>, format: EncodedImageFormat, quality: impl Into<Option<u32>> ) -> Option<Data>

impl RCHandle<GrDirectContext>

pub fn new_gl<'a>( interface: impl Into<Option<Interface>>, options: impl Into<Option<&'a ContextOptions>> ) -> Option<DirectContext>

pub fn reset(&mut self, backend_state: Option<u32>) -> &mut Self

pub fn reset_gl_texture_bindings(&mut self) -> &mut Self

pub fn abandon(&mut self) -> &mut Self

pub fn oomed(&mut self) -> bool

pub fn release_resources_and_abandon(&mut self) -> &mut Self

pub fn resource_cache_limits(&self) -> ResourceCacheLimits

pub fn resource_cache_limit(&self) -> usize

pub fn resource_cache_usage(&self) -> ResourceCacheUsage

pub fn resource_cache_purgeable_bytes(&self) -> usize

pub fn set_resource_cache_limits(&mut self, limits: ResourceCacheLimits)

pub fn set_resource_cache_limit(&mut self, max_resource_bytes: usize)

pub fn free_gpu_resources(&mut self) -> &mut Self

pub fn perform_deferred_cleanup( &mut self, not_used: Duration, scratch_resources_only: impl Into<Option<bool>> ) -> &mut Self

pub fn purge_unlocked_resources( &mut self, bytes_to_purge: Option<usize>, prefer_scratch_resources: bool ) -> &mut Self

pub fn flush_and_submit(&mut self) -> &mut Self

pub fn flush_submit_and_sync_cpu(&mut self) -> &mut Self

pub fn flush_with_info(&mut self, info: &FlushInfo) -> SemaphoresSubmitted

👎Deprecated since 0.37.0: Use flush()

pub fn flush<'a>( &mut self, info: impl Into<Option<&'a FlushInfo>> ) -> SemaphoresSubmitted

pub fn flush_image_with_info( &mut self, image: &Image, info: &FlushInfo ) -> SemaphoresSubmitted

pub fn flush_image(&mut self, image: &Image)

pub fn flush_and_submit_image(&mut self, image: &Image)

pub fn submit(&mut self, sync_cpu: impl Into<Option<bool>>) -> bool

pub fn check_async_work_completion(&mut self)

pub fn supports_distance_field_text(&self) -> bool

pub fn compressed_backend_format( &self, compression: TextureCompressionType ) -> BackendFormat

pub fn set_backend_texture_state( &mut self, backend_texture: &BackendTexture, state: &MutableTextureState ) -> bool

pub fn set_backend_texture_state_and_return_previous( &mut self, backend_texture: &BackendTexture, state: &MutableTextureState ) -> Option<MutableTextureState>

pub fn set_backend_render_target_state( &mut self, target: &BackendRenderTarget, state: &MutableTextureState ) -> bool

pub fn set_backend_render_target_state_and_return_previous( &mut self, target: &BackendRenderTarget, state: &MutableTextureState ) -> Option<MutableTextureState>

pub fn precompile_shader(&mut self, key: &Data, data: &Data) -> bool

pub fn id(&self) -> DirectContextId

impl RCHandle<GrGLInterface>

pub fn new_native() -> Option<Self>

pub fn new_load_with<F>(load_fn: F) -> Option<Self>where F: FnMut(&str) -> *const c_void,

pub fn new_load_with_cstr<F>(load_fn: F) -> Option<Self>where F: FnMut(&CStr) -> *const c_void,

pub fn validate(&self) -> bool

pub fn extensions(&self) -> &Extensions

pub fn extensions_mut(&mut self) -> &mut Extensions

pub fn has_extension(&self, extension: impl AsRef<str>) -> bool

impl RCHandle<GrRecordingContext>

pub fn as_direct_context(&mut self) -> Option<DirectContext>

pub fn backend(&self) -> BackendAPI

pub fn default_backend_format( &self, ct: ColorType, renderable: Renderable ) -> BackendFormat

pub fn compressed_backend_format( &self, compression_type: TextureCompressionType ) -> BackendFormat

pub fn abandoned(&mut self) -> bool

pub fn color_type_supported_as_surface(&self, color_type: ColorType) -> bool

pub fn max_texture_size(&self) -> i32

pub fn max_render_target_size(&self) -> i32

pub fn color_type_supported_as_image(&self, color_type: ColorType) -> bool

pub fn max_surface_sample_count_for_color_type( &self, color_type: ColorType ) -> usize

impl RCHandle<SkOrderedFontMgr>

pub fn new() -> Self

pub fn append(&mut self, font_mgr: impl Into<FontMgr>)

Trait Implementations§

impl<N: NativeRefCounted> AsRef<RCHandle<N>> for RCHandle<N>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<N: NativeRefCounted> Clone for RCHandle<N>

fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl<H: NativeRefCountedBase> ConditionallySend for RCHandle<H>

RCHandle<H> is conditionally Send and can be sent to another thread when its reference count is 1.

fn can_send(&self) -> bool

Returns true if the handle can be sent to another thread.

fn wrap_send(self) -> Result<Sendable<Self>, Self>

Wrap the handle in a type that can be sent to another thread and unwrapped there. Read more

impl<N: NativeRefCounted> Drop for RCHandle<N>

fn drop(&mut self)

Executes the destructor for this type. Read more

impl<N> Flattenable for RCHandle<N>where N: NativeFlattenable + NativeRefCountedBase,

fn type_name(&self) -> &CStr

fn serialize(&self) -> Data

fn deserialize(data: &[u8]) -> Option<Self>

impl<N: NativeRefCounted> From<&RCHandle<N>> for RCHandle<N>

A reference counted handle is cheap to clone, so we do support a conversion from a reference to a ref counter to an owned handle.

fn from(rch: &RCHandle<N>) -> Self

Converts to this type from the input type.

impl From<RCHandle<GrDirectContext>> for RecordingContext

fn from(direct_context: DirectContext) -> Self

Converts to this type from the input type.

impl From<RCHandle<SkBlender>> for ChildPtr

fn from(blender: Blender) -> Self

Converts to this type from the input type.

impl From<RCHandle<SkColorFilter>> for ChildPtr

fn from(color_filter: ColorFilter) -> Self

Converts to this type from the input type.

impl From<RCHandle<SkOrderedFontMgr>> for FontMgr

fn from(font_mgr: OrderedFontMgr) -> Self

Converts to this type from the input type.

impl From<RCHandle<SkShader>> for ChildPtr

fn from(shader: Shader) -> Self

Converts to this type from the input type.

impl<N: NativeRefCounted + NativePartialEq> PartialEq<RCHandle<N>> for RCHandle<N>

fn eq(&self, rhs: &Self) -> bool

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

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<RCHandle<SkData>> for Data

fn eq(&self, other: &Self) -> bool

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

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N> PointerWrapper<N> for RCHandle<N>where N: NativeRefCounted,

fn wrap(ptr: *mut N) -> Option<Self>

Wraps a native pointer into a wrapper type. Returns None if the pointer is null.

fn unwrap(self) -> *mut N

Unwraps the wrapper type into the native pointer.

fn inner(&self) -> &N

Access the wrapped pointer.

fn inner_mut(&mut self) -> &mut N

Access the wrapped pointer.

Auto Trait Implementations§

impl<Native> RefUnwindSafe for RCHandle<Native>where Native: RefUnwindSafe,

impl<Native> !Send for RCHandle<Native>

impl<Native> !Sync for RCHandle<Native>

impl<Native> Unpin for RCHandle<Native>

impl<Native> UnwindSafe for RCHandle<Native>where Native: RefUnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for Twhere U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for Twhere U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for Twhere U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.