Struct cosmic::cosmic_theme::palette::cast::Packed

#[repr(transparent)]
pub struct Packed<O, P> {
    pub color: P,
    pub channel_order: PhantomData<O>,
}

A color packed into a compact format, such as an unsigned integer.

Packed implements ArrayCast and UintCast so it can easily be constructed from slices, arrays and unsigned integers.

// `PackedArgb` is an alias for `Packed<rgb::channels::Argb, P = u32>`.
use palette::{rgb::PackedArgb, cast::UintsAs};

let raw = [0x7F0080u32, 0x60BBCC];
let colors: &[PackedArgb] = raw.uints_as();

assert_eq!(colors.len(), 2);
assert_eq!(colors[0].color, 0x7F0080);
assert_eq!(colors[1].color, 0x60BBCC);

Packed Integer Type Represented in u32.

A common example of a packed format is when an RGBA color is encoded as a hexadecimal number (such as 0x7F0080 from above). Two hexadecimal digits (8-bits) express each value of the Red, Green, Blue, and Alpha components in the RGBA color.

Note that conversion from float to integer component types in Palette rounds to nearest even: an Rgb component of 0.5 will convert to 0x80/128, not 0x7F/127.

use approx::assert_relative_eq;
use palette::{Srgb, Srgba};
use palette::rgb::{PackedArgb, PackedRgba};

let packed: PackedArgb = Srgb::new(0.5, 0.0, 0.5).into_format().into();
assert_eq!(0xFF80_0080, packed.color);

let unpacked: Srgba<u8> = PackedRgba::from(0xFFFF_FF80u32).into();
assert_relative_eq!(
    Srgba::new(1.0, 1.0, 1.0, 0.5),
    unpacked.into_format(),
    epsilon = 0.01
);

// By default, `Packed` uses `Argb` order for creating `Rgb` colors to make
// entering 6-digit hex numbers more convenient
let rgb = Srgb::from(0xFF8000);
assert_eq!(Srgb::new(0xFF, 0x80, 0x00), rgb);

let rgba = Srgba::from(0xFF80007F);
assert_eq!(Srgba::new(0xFF, 0x80, 0x00, 0x7F), rgba);

When an Rgb type is packed, the alpha value will be 0xFF in the corresponding u32. Converting from a packed color type back to an Rgb type will disregard the alpha value.

Fields

color: P

The color packed into a type P, such as u32 or [u8; 4].

channel_order: PhantomData<O>

The channel order for the color components in the packed data. See ComponentOrder.

Implementations

impl<O, P> Packed<O, P>

pub fn pack<C>(color: C) -> Packed<O, P>

where O: ComponentOrder<C, P>,

Transform a color value into a packed memory representation.

pub fn unpack<C>(self) -> C

where O: ComponentOrder<C, P>,

Transform a packed color into a regular color value.

Trait Implementations

impl<O, T, const N: usize> ArrayCast for Packed<O, [T; N]>

type Array = [T; N]

The output type of a cast to an array.

impl<O, T, const N: usize> AsMut<[T]> for Packed<O, [T; N]>

fn as_mut(&mut self) -> &mut [T]

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

impl<O, T, const N: usize> AsMut<[T; N]> for Packed<O, [T; N]>

fn as_mut(&mut self) -> &mut [T; N]

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

impl<O, P> AsMut<P> for Packed<O, P>

where Packed<O, P>: UintCast<Uint = P>,

fn as_mut(&mut self) -> &mut P

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

impl<O, T, const N: usize> AsRef<[T]> for Packed<O, [T; N]>

fn as_ref(&self) -> &[T]

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

impl<O, T, const N: usize> AsRef<[T; N]> for Packed<O, [T; N]>

fn as_ref(&self) -> &[T; N]

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

impl<O, P> AsRef<P> for Packed<O, P>

where Packed<O, P>: UintCast<Uint = P>,

fn as_ref(&self) -> &P

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

impl<O, P> Clone for Packed<O, P>

where P: Clone,

fn clone(&self) -> Packed<O, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O, P> Debug for Packed<O, P>

where O: Debug, P: Debug,

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

Formats the value using the given formatter.

impl<'a, O, T, const N: usize> From<&'a [T; N]> for &'a Packed<O, [T; N]>

fn from(array: &'a [T; N]) -> &'a Packed<O, [T; N]>

Converts to this type from the input type.

impl<'a, O, P> From<&'a P> for &'a Packed<O, P>

where P: AsRef<Packed<O, P>>, Packed<O, P>: UintCast<Uint = P>,

fn from(uint: &'a P) -> &'a Packed<O, P>

Converts to this type from the input type.

impl<'a, O, T, const N: usize> From<&'a Packed<O, [T; N]>> for &'a [T]

fn from(color: &'a Packed<O, [T; N]>) -> &'a [T]

Converts to this type from the input type.

impl<'a, O, T, const N: usize> From<&'a mut [T; N]> for &'a mut Packed<O, [T; N]>

fn from(array: &'a mut [T; N]) -> &'a mut Packed<O, [T; N]>

Converts to this type from the input type.

impl<'a, O, P> From<&'a mut P> for &'a mut Packed<O, P>

where P: AsMut<Packed<O, P>>, Packed<O, P>: UintCast<Uint = P>,

fn from(uint: &'a mut P) -> &'a mut Packed<O, P>

Converts to this type from the input type.

impl<'a, O, T, const N: usize> From<&'a mut Packed<O, [T; N]>> for &'a mut [T]

fn from(color: &'a mut Packed<O, [T; N]>) -> &'a mut [T]

Converts to this type from the input type.

impl<O, T, const N: usize> From<[T; N]> for Packed<O, [T; N]>

fn from(array: [T; N]) -> Packed<O, [T; N]>

Converts to this type from the input type.

impl<S, T, O, P> From<Alpha<Luma<S, T>, T>> for Packed<O, P>

where O: ComponentOrder<Alpha<Luma<S, T>, T>, P>,

fn from(color: Alpha<Luma<S, T>, T>) -> Packed<O, P>

Converts to this type from the input type.

impl<S, T, O, P> From<Alpha<Rgb<S, T>, T>> for Packed<O, P>

where O: ComponentOrder<Alpha<Rgb<S, T>, T>, P>,

fn from(color: Alpha<Rgb<S, T>, T>) -> Packed<O, P>

Converts to this type from the input type.

impl<O, T, const N: usize> From<Box<[T; N]>> for Box<Packed<O, [T; N]>>

fn from(array: Box<[T; N]>) -> Box<Packed<O, [T; N]>>

Converts to this type from the input type.

impl<S, T, P, O> From<Luma<S, T>> for Packed<O, P>

where O: ComponentOrder<Alpha<Luma<S, T>, T>, P>, Alpha<Luma<S, T>, T>: From<Luma<S, T>>,

fn from(color: Luma<S, T>) -> Packed<O, P>

Converts to this type from the input type.

impl<O, P> From<P> for Packed<O, P>

where Packed<O, P>: UintCast<Uint = P>,

fn from(uint: P) -> Packed<O, P>

Converts to this type from the input type.

impl<S, T, O, P> From<Packed<O, P>> for Alpha<Luma<S, T>, T>

where O: ComponentOrder<Alpha<Luma<S, T>, T>, P>,

fn from(packed: Packed<O, P>) -> Alpha<Luma<S, T>, T>

Converts to this type from the input type.

impl<S, T, O, P> From<Packed<O, P>> for Alpha<Rgb<S, T>, T>

where O: ComponentOrder<Alpha<Rgb<S, T>, T>, P>,

fn from(packed: Packed<O, P>) -> Alpha<Rgb<S, T>, T>

Converts to this type from the input type.

impl<S, O, P> From<Packed<O, P>> for Luma<S, u8>

where O: ComponentOrder<Alpha<Luma<S, u8>, u8>, P>,

fn from(packed: Packed<O, P>) -> Luma<S, u8>

Converts to this type from the input type.

impl<S, O, P> From<Packed<O, P>> for Rgb<S, u8>

where O: ComponentOrder<Alpha<Rgb<S, u8>, u8>, P>,

fn from(packed: Packed<O, P>) -> Rgb<S, u8>

Converts to this type from the input type.

impl<S, T, P, O> From<Rgb<S, T>> for Packed<O, P>

where O: ComponentOrder<Alpha<Rgb<S, T>, T>, P>, Alpha<Rgb<S, T>, T>: From<Rgb<S, T>>,

fn from(color: Rgb<S, T>) -> Packed<O, P>

Converts to this type from the input type.

impl<O, P> PartialEq for Packed<O, P>

where O: PartialEq, P: PartialEq,

fn eq(&self, other: &Packed<O, P>) -> 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<'a, O, T, const N: usize> TryFrom<&'a [T]> for &'a Packed<O, [T; N]>

type Error = <&'a [T; N] as TryFrom<&'a [T]>>::Error

The type returned in the event of a conversion error.

fn try_from( slice: &'a [T], ) -> Result<&'a Packed<O, [T; N]>, <&'a Packed<O, [T; N]> as TryFrom<&'a [T]>>::Error>

Performs the conversion.

impl<'a, O, T, const N: usize> TryFrom<&'a mut [T]> for &'a mut Packed<O, [T; N]>

type Error = <&'a mut [T; N] as TryFrom<&'a mut [T]>>::Error

The type returned in the event of a conversion error.

fn try_from( slice: &'a mut [T], ) -> Result<&'a mut Packed<O, [T; N]>, <&'a mut Packed<O, [T; N]> as TryFrom<&'a mut [T]>>::Error>

Performs the conversion.

impl<O> UintCast for Packed<O, u128>

type Uint = u128

An unsigned integer with the same size as Self.

impl<O> UintCast for Packed<O, u16>

type Uint = u16

An unsigned integer with the same size as Self.

impl<O> UintCast for Packed<O, u32>

type Uint = u32

An unsigned integer with the same size as Self.

impl<O> UintCast for Packed<O, u64>

type Uint = u64

An unsigned integer with the same size as Self.

impl<O> UintCast for Packed<O, u8>

type Uint = u8

An unsigned integer with the same size as Self.

impl<O, P> Copy for Packed<O, P>

where P: Copy,

impl<O, P> Eq for Packed<O, P>

where O: Eq, P: Eq,

impl<O, P> StructuralPartialEq for Packed<O, P>