Struct bevy::render::texture::Image

pub struct Image {
    pub data: Vec<u8, Global>,
    pub texture_descriptor: TextureDescriptor<Option<&'static str>>,
    pub sampler_descriptor: SamplerDescriptor<'static>,
}

Fields

data: Vec<u8, Global>

texture_descriptor: TextureDescriptor<Option<&'static str>>

sampler_descriptor: SamplerDescriptor<'static>

Implementations

impl Image

pub fn new(
    size: Extent3d,
    dimension: TextureDimension,
    data: Vec<u8, Global>,
    format: TextureFormat
) -> Image

Creates a new image from raw binary data and the corresponding metadata.

Panics

Panics if the length of the data, volume of the size and the size of the format do not match.

pub fn new_fill(
    size: Extent3d,
    dimension: TextureDimension,
    pixel: &[u8],
    format: TextureFormat
) -> Image

Creates a new image from raw binary data and the corresponding metadata, by filling the image data with the pixel data repeated multiple times.

Panics

Panics if the size of the format is not a multiple of the length of the pixel data. do not match.

pub fn aspect_2d(&self) -> f32

Returns the aspect ratio (height/width) of a 2D image.

pub fn size(&self) -> Vec2

Returns the size of a 2D image.

pub fn resize(&mut self, size: Extent3d)

Resizes the image to the new size, by removing information or appending 0 to the data. Does not properly resize the contents of the image, but only its internal data buffer.

pub fn reinterpret_size(&mut self, new_size: Extent3d)

Changes the size, asserting that the total number of data elements (pixels) remains the same.

Panics

Panics if the new_size does not have the same volume as to old one.

pub fn reinterpret_stacked_2d_as_array(&mut self, layers: u32)

Takes a 2D image containing vertically stacked images of the same size, and reinterprets it as a 2D array texture, where each of the stacked images becomes one layer of the array. This is primarily for use with the texture2DArray shader uniform type.

Panics

Panics if the texture is not 2D, has more than one layers or is not evenly dividable into the layers.

pub fn convert(&self, new_format: TextureFormat) -> Option<Image>

Convert a texture from a format to another Only a few formats are supported as input and output:

• TextureFormat::R8Unorm
• TextureFormat::Rg8Unorm
• TextureFormat::Rgba8UnormSrgb
• TextureFormat::Bgra8UnormSrgb

pub fn from_buffer(
    buffer: &[u8],
    image_type: ImageType<'_>,
    supported_compressed_formats: CompressedImageFormats,
    is_srgb: bool
) -> Result<Image, TextureError>

Load a bytes buffer in a Image, according to type image_type, using the image crate

pub fn is_compressed(&self) -> bool

Whether the texture format is compressed or uncompressed

Trait Implementations

impl Clone for Image

fn clone(&self) -> Image

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Image

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

Formats the value using the given formatter.

impl Default for Image

fn default() -> Image

Returns the “default value” for a type.

impl RenderAsset for Image

fn extract_asset(&self) -> <Image as RenderAsset>::ExtractedAsset

Clones the Image.

fn prepare_asset(
    image: <Image as RenderAsset>::ExtractedAsset,
    &mut <<<Image as RenderAsset>::Param as SystemParam>::Fetch as SystemParamFetch<'_, '_>>::Item
) -> Result<<Image as RenderAsset>::PreparedAsset, PrepareAssetError<<Image as RenderAsset>::ExtractedAsset>>

Converts the extracted image into a GpuImage.

type ExtractedAsset = Image

The representation of the the asset in the “render world”.

type PreparedAsset = GpuImage

The GPU-representation of the the asset.

type Param = (Res<'static, RenderDevice>, Res<'static, Arc<Queue>>)

Specifies all ECS data required by RenderAsset::prepare_asset. For convenience use the lifetimeless SystemParam.

impl TypeUuid for Image

const TYPE_UUID: Uuid = bevy_reflect::Uuid::from_bytes([110, 162, 109, 166, 108, 248, 78, 162, 153, 134, 29, 123, 246, 193, 125, 111])