Struct web_glitz::image::texture_3d::LevelLayersMut

pub struct LevelLayersMut<'a, F> { /* fields omitted */ }

A mutable reference to a the layers of a mipmap level of a Texture3D.

Derefs to LevelLayers.

Implementations

impl<'a, F> LevelLayersMut<'a, F>

pub fn get_mut<'b, I>(&'b mut self, index: I) -> Option<I::Output> where
    I: LevelLayersMutIndex<'b, F>, 

pub unsafe fn get_unchecked_mut<'b, I>(&'b mut self, index: I) -> I::Output where
    I: LevelLayersMutIndex<'b, F>, 

pub fn iter_mut(&mut self) -> LevelLayersMutIter<'_, F>

Methods from Deref<Target = LevelLayers<'a, F>>

pub fn len(&self) -> usize

The number of layers for the level.

Note that each mipmap level for a Texture3D as the same number of layers.

pub fn get<'b, I>(&'b self, index: I) -> Option<I::Output> where
    I: LevelLayersIndex<'b, F>, 

Returns a reference to the layer at the index, or None if the index is out of bounds.

See also [get_unchecked] for an unsafe variant of this method that does not do any bounds checks.

Example

use web_glitz::image::MipmapLevels;
use web_glitz::image::format::RGB8;
use web_glitz::image::texture_3d::Texture3DDescriptor;

let texture = context.try_create_texture_3d(&Texture3DDescriptor {
    format: RGB8,
    width: 256,
    height: 256,
    depth: 16,
    levels: MipmapLevels::Partial(3)
}).unwrap();

let base_level = texture.base_level();
let layers = base_level.layers();

assert_eq!(layers.get(1).map(|l| (l.width(), l.height())), Some((128, 128)));
assert_eq!(layers.get(4).map(|l| (l.width(), l.height())), None);

pub unsafe fn get_unchecked<'b, I>(&'b self, index: I) -> I::Output where
    I: LevelLayersIndex<'b, F>, 

Returns a reference to layer at the index, without doing any bounds checks.

Example

use web_glitz::image::MipmapLevels;
use web_glitz::image::format::RGB8;
use web_glitz::image::texture_3d::Texture3DDescriptor;

let texture = context.try_create_texture_3d(&Texture3DDescriptor {
    format: RGB8,
    width: 256,
    height: 256,
    depth: 16,
    levels: MipmapLevels::Partial(3)
}).unwrap();

let base_level = texture.base_level();
let layers = base_level.layers();

let layer = unsafe { layers.get_unchecked(1) };

assert_eq!((layer.width(), layer.height()), (128, 128));

Unsafe

The index must be in bounds. See also [get] for a safe variant of this method that does bounds checks.

pub fn iter(&self) -> LevelLayersIter<'_, F>

Returns an iterator over the layers.

Example

use web_glitz::image::MipmapLevels;
use web_glitz::image::format::RGB8;
use web_glitz::image::texture_3d::Texture3DDescriptor;

let texture = context.try_create_texture_3d(&Texture3DDescriptor {
    format: RGB8,
    width: 256,
    height: 256,
    depth: 4,
    levels: MipmapLevels::Complete
}).unwrap();

let base_level = texture.base_level();
let layers = base_level.layers();
let mut iter = layers.iter();

assert!(iter.next().is_some());
assert!(iter.next().is_some());
assert!(iter.next().is_some());
assert!(iter.next().is_some());
assert!(iter.next().is_none());

Trait Implementations

impl<'a, F> Deref for LevelLayersMut<'a, F>

type Target = LevelLayers<'a, F>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, F: Hash> Hash for LevelLayersMut<'a, F>

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, 

Feeds a slice of this type into the given Hasher.

impl<'a, F> IntoIterator for LevelLayersMut<'a, F> where
    F: TextureFormat, 

type Item = LevelLayerMut<'a, F>

The type of the elements being iterated over.

type IntoIter = LevelLayersMutIter<'a, F>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, F: PartialEq> PartialEq<LevelLayersMut<'a, F>> for LevelLayersMut<'a, F>

fn eq(&self, other: &LevelLayersMut<'a, F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &LevelLayersMut<'a, F>) -> bool

This method tests for !=.

impl<'a, F> StructuralPartialEq for LevelLayersMut<'a, F>