Enum ColorType

#[repr(i32)]
pub enum ColorType {
    Unknown = 0,
    Alpha8 = 1,
    RGB565 = 2,
    ARGB4444 = 3,
    RGBA8888 = 4,
    RGB888x = 5,
    BGRA8888 = 6,
    RGBA1010102 = 7,
    BGRA1010102 = 8,
    RGB101010x = 9,
    BGR101010x = 10,
    BGR101010xXR = 11,
    BGRA10101010XR = 12,
    RGBA10x6 = 13,
    Gray8 = 14,
    RGBAF16Norm = 15,
    RGBAF16 = 16,
    RGBF16F16F16x = 17,
    RGBAF32 = 18,
    R8G8UNorm = 19,
    A16Float = 20,
    R16G16Float = 21,
    A16UNorm = 22,
    R16G16UNorm = 23,
    R16G16B16A16UNorm = 24,
    SRGBA8888 = 25,
    R8UNorm = 26,
}

Variants

Unknown = 0

uninitialized

Alpha8 = 1

pixel with alpha in 8-bit byte

RGB565 = 2

pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word

ARGB4444 = 3

pixel with 4 bits for alpha, red, green, blue; in 16-bit word

RGBA8888 = 4

pixel with 8 bits for red, green, blue, alpha; in 32-bit word

RGB888x = 5

pixel with 8 bits each for red, green, blue; in 32-bit word

BGRA8888 = 6

pixel with 8 bits for blue, green, red, alpha; in 32-bit word

RGBA1010102 = 7

10 bits for red, green, blue; 2 bits for alpha; in 32-bit word

BGRA1010102 = 8

10 bits for blue, green, red; 2 bits for alpha; in 32-bit word

RGB101010x = 9

pixel with 10 bits each for red, green, blue; in 32-bit word

BGR101010x = 10

pixel with 10 bits each for blue, green, red; in 32-bit word

BGR101010xXR = 11

pixel with 10 bits each for blue, green, red; in 32-bit word, extended range

BGRA10101010XR = 12

pixel with 10 bits each for blue, green, red, alpha; in 64-bit word, extended range

RGBA10x6 = 13

pixel with 10 used bits (most significant) followed by 6 unused bits for red, green, blue, alpha; in 64-bit word

Gray8 = 14

pixel with grayscale level in 8-bit byte

RGBAF16Norm = 15

pixel with half floats in [0,1] for red, green, blue, alpha in 64-bit word

RGBAF16 = 16

pixel with half floats for red, green, blue, alpha in 64-bit word

RGBF16F16F16x = 17

pixel with half floats for red, green, blue; in 64-bit word

RGBAF32 = 18

pixel using C float for red, green, blue, alpha; in 128-bit word

R8G8UNorm = 19

pixel with a uint8_t for red and green

A16Float = 20

pixel with a half float for alpha

R16G16Float = 21

pixel with a half float for red and green

A16UNorm = 22

pixel with a little endian uint16_t for alpha

R16G16UNorm = 23

pixel with a little endian uint16_t for red and green

R16G16B16A16UNorm = 24

pixel with a little endian uint16_t for red, green, blue and alpha

SRGBA8888 = 25

R8UNorm = 26

Implementations

impl ColorType

pub const N32: ColorType = _

pub const COUNT: usize = 27usize

pub const fn n32() -> ColorType

👎Deprecated since 0.51.0: Use ColorType::N32

pub fn bytes_per_pixel(self) -> usize

pub fn is_always_opaque(self) -> bool

pub fn validate_alpha_type(self, alpha_type: SkAlphaType) -> Option<SkAlphaType>

Trait Implementations

impl Clone for ColorType

fn clone(&self) -> ColorType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ColorType

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

Formats the value using the given formatter.

impl Hash for ColorType

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ColorType

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for ColorType

impl Eq for ColorType

impl StructuralPartialEq for ColorType