Struct AlphaLast

#[repr(C)]
pub struct AlphaLast<A, C> { /* private fields */ }

A contiguous color with alpha last, preceded by other color components.

Layout

template<typename C, typename A>
struct AlphaLast {
  C color;
  A alpha;
}

Implementations

impl<A, C> AlphaLast<A, C>

pub const fn with_color(alpha: A, color: C) -> Self

Creates a new instance of AlphaFirst with the given color and alpha components.

pub const fn alpha(&self) -> A

where A: Copy,

Returns the alpha component of this color.

pub const fn color(&self) -> C

where C: Copy,

Returns the color component of this color.

pub fn into_inner(self) -> (C, A)

Consumes and returns the color and alpha components of this color.

impl AlphaLast<u8, Gray<u8>>

pub const fn new(gray: u8, alpha: u8) -> Self

Creates a new 8-bit grayscale color with alpha.

impl AlphaLast<u16, Gray<u16>>

pub const fn new(gray: u16, alpha: u16) -> Self

Creates a new 16-bit grayscale color with alpha.

impl AlphaLast<f32, Gray<f32>>

pub const fn new(gray: f32, alpha: f32) -> Self

Creates a new 32-bit floating-point grayscale color with alpha.

impl AlphaLast<f32, Rgb<f32>>

pub const fn from_rgba(r: f32, g: f32, b: f32, a: f32) -> Self

Creates a new RGBA color from the individual components.

Examples

use gem::{alpha::HasAlpha, rgb::{HasRed, HasGreen, HasBlue, Rgbaf32}};

let color = Rgbaf32::from_rgba(1.0, 0.0, 0.0, 1.0);
assert_eq!(color.red(), 1.0);
assert_eq!(color.green(), 0.0);
assert_eq!(color.blue(), 0.0);
assert_eq!(color.alpha(), 1.0);

Trait Implementations

impl<A: Clone, C: Clone> Clone for AlphaLast<A, C>

fn clone(&self) -> AlphaLast<A, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, C: Debug> Debug for AlphaLast<A, C>

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

Formats the value using the given formatter.

impl<A: Default, C: Default> Default for AlphaLast<A, C>

fn default() -> AlphaLast<A, C>

Returns the “default value” for a type.

impl<A, C> HasAlpha for AlphaLast<A, C>

where A: Copy,

type Component = A

The type of the alpha component.

fn alpha(&self) -> Self::Component

Returns the value of the alpha component.

fn set_alpha(&mut self, value: Self::Component)

Sets the alpha component to the given value.

fn new_alpha(value: Self::Component) -> Self

where Self: Sized + Default,

Creates a new color with the given alpha component.

fn with_alpha(self, value: Self::Component) -> Self

where Self: Sized,

Converts the color into a new type with the alpha component set to the given value.

impl<A, C> HasBlue for AlphaLast<A, C>

where A: Copy, C: Copy + HasBlue,

type Component = <C as HasBlue>::Component

The type of the blue component.

fn blue(&self) -> Self::Component

Returns the value of the blue component.

fn set_blue(&mut self, value: Self::Component)

Sets the blue component to the given value.

fn with_blue(self, value: Self::Component) -> Self

where Self: Copy + Clone,

Converts the color into a new type with the blue component set to the given value.

impl<A, C> HasGreen for AlphaLast<A, C>

where A: Copy, C: Copy + HasGreen,

type Component = <C as HasGreen>::Component

The type of the green component.

fn green(&self) -> Self::Component

Returns the value of the green component.

fn set_green(&mut self, value: Self::Component)

Sets the green component to the given value.

fn with_green(self, value: Self::Component) -> Self

where Self: Copy + Clone,

Converts the color into a new type with the green component set to the given value.

impl<A, C> HasRed for AlphaLast<A, C>

where A: Copy, C: Copy + HasRed,

type Component = <C as HasRed>::Component

The type of the red component.

fn red(&self) -> Self::Component

Returns the value of the red component.

fn set_red(&mut self, value: Self::Component)

Sets the red component to the given value.

fn with_red(self, value: Self::Component) -> Self

where Self: Copy + Clone,

Converts the color into a new type with the red component set to the given value.

impl<A: Ord, C: Ord> Ord for AlphaLast<A, C>

fn cmp(&self, other: &AlphaLast<A, C>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<A: PartialEq, C: PartialEq> PartialEq for AlphaLast<A, C>

fn eq(&self, other: &AlphaLast<A, C>) -> 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: PartialOrd, C: PartialOrd> PartialOrd for AlphaLast<A, C>

fn partial_cmp(&self, other: &AlphaLast<A, C>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<A, C> Zeroable for AlphaLast<A, C>

where A: Zeroable, C: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<A: Copy, C: Copy> Copy for AlphaLast<A, C>

impl<A: Eq, C: Eq> Eq for AlphaLast<A, C>

impl<A, C> Pod for AlphaLast<A, C>

where A: Pod, C: Pod,

impl<A, C> StructuralPartialEq for AlphaLast<A, C>