Struct bevy::render::render_resource::ErasedTexture

pub struct ErasedTexture(/* private fields */);

Available on not (WebAssembly and target feature atomics).

Implementations

impl ErasedTexture

pub fn new(value: Texture) -> ErasedTexture

pub fn try_unwrap(self) -> Option<Texture>

Methods from Deref<Target = Texture>

pub unsafe fn as_hal<A, F>(&self, hal_texture_callback: F)

where A: HalApi, F: FnOnce(Option<&<A as Api>::Texture>),

Available on wgpu_core only.

Returns the inner hal Texture using a callback. The hal texture will be None if the backend type argument does not match with this wgpu Texture

Safety

• The raw handle obtained from the hal Texture must not be manually destroyed

pub fn create_view(&self, desc: &TextureViewDescriptor<'_>) -> TextureView

Creates a view of this texture.

pub fn destroy(&self)

Destroy the associated native resources as soon as possible.

pub fn as_image_copy(&self) -> ImageCopyTexture<&Texture>

Make an ImageCopyTexture representing the whole texture.

Examples found in repository

examples/app/headless_renderer.rs (line 375)

    fn run(
        &self,
        _graph: &mut RenderGraphContext,
        render_context: &mut RenderContext,
        world: &World,
    ) -> Result<(), NodeRunError> {
        let image_copiers = world.get_resource::<ImageCopiers>().unwrap();
        let gpu_images = world
            .get_resource::<RenderAssets<bevy::render::texture::GpuImage>>()
            .unwrap();

        for image_copier in image_copiers.iter() {
            if !image_copier.enabled() {
                continue;
            }

            let src_image = gpu_images.get(&image_copier.src_image).unwrap();

            let mut encoder = render_context
                .render_device()
                .create_command_encoder(&CommandEncoderDescriptor::default());

            let block_dimensions = src_image.texture_format.block_dimensions();
            let block_size = src_image.texture_format.block_copy_size(None).unwrap();

            let padded_bytes_per_row = RenderDevice::align_copy_bytes_per_row(
                (src_image.size.x as usize / block_dimensions.0 as usize) * block_size as usize,
            );

            let texture_extent = Extent3d {
                width: src_image.size.x,
                height: src_image.size.y,
                depth_or_array_layers: 1,
            };

            encoder.copy_texture_to_buffer(
                src_image.texture.as_image_copy(),
                ImageCopyBuffer {
                    buffer: &image_copier.buffer,
                    layout: ImageDataLayout {
                        offset: 0,
                        bytes_per_row: Some(
                            std::num::NonZeroU32::new(padded_bytes_per_row as u32)
                                .unwrap()
                                .into(),
                        ),
                        rows_per_image: None,
                    },
                },
                texture_extent,
            );

            let render_queue = world.get_resource::<RenderQueue>().unwrap();
            render_queue.submit(std::iter::once(encoder.finish()));
        }

        Ok(())
    }

pub fn size(&self) -> Extent3d

Returns the size of this Texture.

This is always equal to the size that was specified when creating the texture.

pub fn width(&self) -> u32

Returns the width of this Texture.

This is always equal to the size.width that was specified when creating the texture.

pub fn height(&self) -> u32

Returns the height of this Texture.

This is always equal to the size.height that was specified when creating the texture.

pub fn depth_or_array_layers(&self) -> u32

Returns the depth or layer count of this Texture.

This is always equal to the size.depth_or_array_layers that was specified when creating the texture.

pub fn mip_level_count(&self) -> u32

Returns the mip_level_count of this Texture.

This is always equal to the mip_level_count that was specified when creating the texture.

pub fn sample_count(&self) -> u32

Returns the sample_count of this Texture.

This is always equal to the sample_count that was specified when creating the texture.

pub fn dimension(&self) -> TextureDimension

Returns the dimension of this Texture.

This is always equal to the dimension that was specified when creating the texture.

pub fn format(&self) -> TextureFormat

Returns the format of this Texture.

This is always equal to the format that was specified when creating the texture.

pub fn usage(&self) -> TextureUsages

Returns the allowed usages of this Texture.

This is always equal to the usage that was specified when creating the texture.

pub fn global_id(&self) -> Id<Texture>

Returns a globally-unique identifier for this Texture.

Calling this method multiple times on the same object will always return the same value. The returned value is guaranteed to be different for all resources created from the same Instance.

Trait Implementations

impl Clone for ErasedTexture

fn clone(&self) -> ErasedTexture

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ErasedTexture

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

Formats the value using the given formatter.

impl Deref for ErasedTexture

type Target = Texture

The resulting type after dereferencing.

fn deref(&self) -> &<ErasedTexture as Deref>::Target

Dereferences the value.

impl Drop for ErasedTexture

fn drop(&mut self)

Executes the destructor for this type.

impl Send for ErasedTexture

impl Sync for ErasedTexture