Struct web_glitz::image::texture_2d::Level

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

A reference to a mipmap level of a Texture2D.

A reference to the base level of a Texture2D can be obtained through Texture2D::base_level. References to other levels of a Texture2D can be obtained via Levels.

Implementations

impl<'a, F> Level<'a, F> where
    F: TextureFormat, 

pub fn level(&self) -> usize

Returns the integer that identifies this level.

For example, if this Level is the texture's base level, returns 0; if it is the second level, returns 1; etc.

pub fn width(&self) -> u32

Returns the width of this level.

pub fn height(&self) -> u32

Returns the height of this level.

pub fn sub_image(&self, region: Region2D) -> LevelSubImage<'_, F>

Returns a reference to the sub-region of this Level's image described by region.

Example

This may for example be used to upload data to only a sub-region of an image, rather than the complete image:

use web_glitz::image::{Image2DSource, MipmapLevels, Region2D};
use web_glitz::image::format::RGB8;
use web_glitz::image::texture_2d::Texture2DDescriptor;

let texture = context.try_create_texture_2d(&Texture2DDescriptor {
    format: RGB8,
    width: 256,
    height: 256,
    levels: MipmapLevels::Complete
}).unwrap();

let base_level = texture.base_level();
let sub_image = base_level.sub_image(Region2D::Area((0, 0), 128, 128));

let pixels: Vec<[u8; 3]> = vec![[0, 0, 255]; 128 * 128];
let data = Image2DSource::from_pixels(pixels, 128, 128).unwrap();

context.submit(sub_image.upload_command(data));

The lower left quadrant of the texture's base level now contains blue pixels, while the rest of the base levels remains black (texture storage starts out with all bits set to 0, which with format [RGB8] is interpreted as black).

pub fn upload_command<D, T>(
    &self,
    data: Image2DSource<D, T>
) -> UploadCommand<D, T, F> where
    T: PixelUnpack<F>, 

Returns a command which, when executed, replaces the image data in this Level's image with the image data provided in data.

The image data must be stored as a PixelUnpack type that is suitable for the texture's TextureFormat.

If the dimensions of the image provided in data are not sufficient to cover the Level's image entirely, starting from the origin, then only the region of overlap is updated (note that the origin of an image is the lower left corner). For example, given a Level with a width of 256 pixels and a height of 256 pixels, and data with a width of 128 pixels and a height of 128 pixels, then only the lower left quadrant of the Level is updated. If the dimensions of the image provided in data would, when starting from the origin, cover more than the Level's image (the width and/or height of data is/are greater than the width and/or height of the Level's image), then any pixels that would fall outside of the Level are ignored. For example, given a Level with a width of 256 pixels and a height of 256 pixels, and data with a width of 256 pixels and a height of 512 pixels, then only the lower half of the image in data is used to update the Level and the upper half is ignored.

Example

use web_glitz::image::{Image2DSource, MipmapLevels};
use web_glitz::image::format::RGB8;
use web_glitz::image::texture_2d::Texture2DDescriptor;

let texture = context.try_create_texture_2d(&Texture2DDescriptor {
    format: RGB8,
    width: 256,
    height: 256,
    levels: MipmapLevels::Complete
}).unwrap();

let pixels: Vec<[u8; 3]> = vec![[255, 0, 0]; 256 * 256];
let data = Image2DSource::from_pixels(pixels, 256, 256).unwrap();

context.submit(texture.base_level().upload_command(data));

pub fn pack_to_buffer_command<P>(
    &self,
    buffer: BufferView<'_, [P]>
) -> PackToBufferCommand<F, P> where
    P: PixelPack<F>, 

Trait Implementations

impl<'a, F> BlitSource for Texture2DLevel<'a, F> where
    F: TextureFormat + 'static, 

type Format = F

The image storage format used by the source image.

fn descriptor(&self) -> BlitSourceDescriptor

Encapsulates the information about the blit source required by the BlitCommand.

impl<'a, F: Hash> Hash for Level<'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: PartialEq> PartialEq<Level<'a, F>> for Level<'a, F>

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

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

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

This method tests for !=.

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