Struct Abgr

#[repr(C)]
pub struct Abgr<T> {
    pub a: T,
    pub b: T,
    pub g: T,
    pub r: T,
}

An ABGR pixel.

Fields

a: T

Alpha Component

b: T

Blue Component

g: T

Green Component

r: T

Red Component

Trait Implementations

impl<T: Clone> Clone for Abgr<T>

fn clone(&self) -> Abgr<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> ContiguousPixel for Abgr<T>

where T: PixelComponent,

fn from_component_slice_ref(slice: &[Self::Component]) -> &Self

Returns a reference to the pixel type from a slice with the same number of components.

fn from_component_slice_mut(slice: &mut [Self::Component]) -> &mut Self

Returns a mutable reference to the pixel type from a slice with the same number of components.

impl<T: Debug> Debug for Abgr<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Abgr<T>

fn default() -> Abgr<T>

Returns the “default value” for a type.

impl<R, S> From<[R; 4]> for Abgr<S>

where R: Into<S>,

fn from(value: [R; 4]) -> Self

Converts to this type from the input type.

impl<R, S> From<Abgr<R>> for [S; 4]

where R: Into<S>,

fn from(value: Abgr<R>) -> Self

Converts to this type from the input type.

impl<R, S> From<Abgr<R>> for Argb<S>

where R: Into<S>,

fn from(value: Abgr<R>) -> Self

Converts to this type from the input type.

impl<R, S> From<Abgr<R>> for Bgr<S>

where R: Into<S>,

fn from(value: Abgr<R>) -> Self

Converts to this type from the input type.

impl<R, S> From<Abgr<R>> for Bgra<S>

where R: Into<S>,

fn from(value: Abgr<R>) -> Self

Converts to this type from the input type.

impl<R, S> From<Abgr<R>> for Rgb<S>

where R: Into<S>,

fn from(value: Abgr<R>) -> Self

Converts to this type from the input type.

impl<R, S> From<Abgr<R>> for Rgba<S>

where R: Into<S>,

fn from(value: Abgr<R>) -> Self

Converts to this type from the input type.

impl<R, S> From<Argb<R>> for Abgr<S>

where R: Into<S>,

fn from(value: Argb<R>) -> Self

Converts to this type from the input type.

impl<R, S> From<Bgra<R>> for Abgr<S>

where R: Into<S>,

fn from(value: Bgra<R>) -> Self

Converts to this type from the input type.

impl<R, S> From<Rgba<R>> for Abgr<S>

where R: Into<S>,

fn from(value: Rgba<R>) -> Self

Converts to this type from the input type.

impl<R, S> FromPixelCommon<Abgr<R>> for Abgr<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Abgr<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Abgr<R>> for Argb<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Abgr<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Abgr<R>> for Bgr<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Abgr<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Abgr<R>> for Bgra<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Abgr<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Abgr<R>> for Gray<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Abgr<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Abgr<R>> for GrayAlpha<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Abgr<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Abgr<R>> for Rgb<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Abgr<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Abgr<R>> for Rgba<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Abgr<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Argb<R>> for Abgr<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Argb<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Bgr<R>> for Abgr<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Bgr<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Bgra<R>> for Abgr<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Bgra<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Gray<R>> for Abgr<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Gray<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<GrayAlpha<R>> for Abgr<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: GrayAlpha<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Rgb<R>> for Abgr<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Rgb<R>) -> Self

Converts the given pixel type to the Self type.

impl<R, S> FromPixelCommon<Rgba<R>> for Abgr<S>

where R: PixelComponent + Enlargeable, S: PixelComponent + FromComponentCommon<R>,

fn from_pixel_common(pixel: Rgba<R>) -> Self

Converts the given pixel type to the Self type.

impl<T: Hash> Hash for Abgr<T>

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

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<T: Ord> Ord for Abgr<T>

fn cmp(&self, other: &Abgr<T>) -> 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<T: PartialEq> PartialEq for Abgr<T>

fn eq(&self, other: &Abgr<T>) -> 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<T: PartialOrd> PartialOrd for Abgr<T>

fn partial_cmp(&self, other: &Abgr<T>) -> 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<T> Pixel for Abgr<T>

where T: PixelComponent,

const COMPONENT_COUNT: u8 = 4u8

The total number of components in the pixel.

type Component = T

The component type of the pixel used for both color and alpha components if any.

type SelfType<U: PixelComponent> = Abgr<U>

The same pixel type as Self but with a different component type U

type ComponentArray<R> = [R; 4]

The component array form of Self

type ColorArray<R> = [R; 3]

The color array form of Self

fn component_array(&self) -> Self::ComponentArray<Self::Component>

Converts an owned Pixel type to an array of its components.

fn color_array(&self) -> Self::ColorArray<Self::Component>

Converts an owned Pixel type to an array of its color components.

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

Returns the alpha component of the pixel if it has one.

fn from_components( components: impl IntoIterator<Item = Self::Component>, ) -> Self

Creates a new instance given an iterator of its components.

fn from_colors_alpha( colors: impl IntoIterator<Item = Self::Component>, alpha: Self::Component, ) -> Self

Create a new instance given an array of its color components and an alpha component.

fn map_components<U>( &self, f: impl FnMut(Self::Component) -> U, ) -> Self::SelfType<U>

where U: PixelComponent,

Maps each of the pixels components with a function f.

fn map_colors(&self, f: impl FnMut(Self::Component) -> Self::Component) -> Self

Maps each of the pixels color components with a function f.

fn map_alpha(&self, f: impl FnMut(Self::Component) -> Self::Component) -> Self

Maps the pixels alpha components with a function f.

impl<T> WithAlpha for Abgr<T>

where T: PixelComponent,

type WithAlpha = Abgr<T>

The pixel type with its alpha component.

fn with_alpha(self) -> Self::WithAlpha

Returns the pixel type with its alpha component. If no alpha component is already contained then it is set to the maximum value. PixelComponent.

impl<T: Copy> Copy for Abgr<T>

impl<T: Eq> Eq for Abgr<T>

impl<T> StructuralPartialEq for Abgr<T>