Enum `Blocks`

pub enum Blocks

How the image pixels are split up into separate blocks.

Variants

ScanLines

The image is divided into scan line blocks. The number of scan lines in a block depends on the compression method.

Tiles(Vec2<usize>)

The image is divided into tile blocks. Also specifies the size of each tile in the image and whether this image contains multiple resolution levels.

The inner Vec2 describes the size of each tile. Stays the same number of pixels across all levels.

Trait Implementations

`impl Clone for Blocks`

fn clone(&self) -> Self

`impl Copy for Blocks`

`impl Debug for Blocks`

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

`impl Eq for Blocks`

`impl PartialEq for Blocks`

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

`impl StructuralPartialEq for Blocks`

Auto Trait Implementations

`impl Freeze for Blocks`

`impl RefUnwindSafe for Blocks`

`impl Send for Blocks`

`impl Sync for Blocks`

`impl Unpin for Blocks`

`impl UnsafeUnpin for Blocks`

`impl UnwindSafe for Blocks`

Blanket Implementations

`impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for Blocks where ST: ?Sized, DT: ?Sized,`

`impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for Blocks where ST: ?Sized, DT: ?Sized,`

`impl<T> Any for Blocks where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Blocks where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Blocks where T: ?Sized,`

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

`impl<T> CloneToUninit for Blocks where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for Blocks`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Pointable for Blocks`

const ALIGN: usize = _;
type Init = T;
unsafe fn init(init: <T as Pointable>::Init) -> usize
unsafe fn deref<'a>(ptr: usize) -> &'a T
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
unsafe fn drop(ptr: usize)

`impl<T> Read<Exclusive, BecauseExclusive> for Blocks where T: ?Sized,`

`impl<T> ToOwned for Blocks where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T, U> Into for Blocks where 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, U> TryFrom for Blocks where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto for Blocks where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>