Struct Image 

pub struct Image {
    pub device: Device,
    pub handle: Image,
    pub info: ImageInfo,
    /* private fields */
}

Smart pointer handle to an image object.

Also contains information about the object.

let fmt = vk::Format::R8G8B8A8_UNORM;
let usage = vk::ImageUsageFlags::SAMPLED;
let info = ImageInfo::image_2d(320, 200, fmt, usage);
let my_img = Image::create(&device, info)?;

assert_eq!(my_img.info, info);
assert_ne!(my_img.handle, vk::Image::null());

Fields

device: Device

The device which owns this image resource.

Note: This field is read-only.

handle: Image

The native Vulkan resource handle of this image.

Note: This field is read-only.

info: ImageInfo

Information used to create this resource.

Note: This field is read-only.

Implementations

impl Image

pub fn create( device: &Device, info: impl Into<ImageInfo>, ) -> Result<Self, DriverError>

Creates a new image on the given device.

Examples

Basic usage:

let info = ImageInfo::image_2d(
    32,
    32,
    vk::Format::R8G8B8A8_UNORM,
    vk::ImageUsageFlags::SAMPLED,
);
let image = Image::create(&device, info)?;

assert_ne!(image.handle, vk::Image::null());
assert_eq!(image.info.width, 32);
assert_eq!(image.info.height, 32);

pub unsafe fn from_raw( device: &Device, handle: Image, info: impl Into<ImageInfo>, ) -> Self

Consumes a Vulkan image created by some other library.

The image is not destroyed automatically on drop, unlike images created through the Image::create function.

Safety

handle must be a valid vk::Image created from device, and info must accurately describe the image’s format, extent, usage, sharing mode, and subresource counts. The caller remains responsible for keeping the handle and its memory backing valid until all wrappers created from this function are no longer used.

pub fn set_debug_name(&self, name: impl AsRef<str>)

Sets the debugging name assigned to this image.

pub fn sync_info(&self) -> ImageSyncInfo

Returns compact synchronization information for the image’s current subresource accesses.

pub unsafe fn to_detached(&self) -> Self

Produces a new Image sharing the same Vulkan handle with independent access tracking.

The returned image retains the handle, device, and debug name of self but starts with no prior access history (AccessType::Nothing) and does not claim ownership of the image’s memory backing. Internal caches are moved out of self so they are not duplicated.

This is used to create separate tracking instances for swapchain images that may be used concurrently across different graph executions.

Safety

The caller must ensure the Vulkan image handle remains valid for the lifetime of the returned Image. This function should only be called on swapchain images or other platform or extension images.

pub fn with_debug_name(self, name: impl AsRef<str>) -> Self

Sets the debugging name assigned to this image.

Trait Implementations

impl Debug for Image

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

Formats the value using the given formatter.

impl Drop for Image

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for Image

impl PartialEq for Image

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Pool<ImageInfo, Image> for FifoPool

fn resource(&mut self, info: ImageInfo) -> Result<Lease<Image>, DriverError>

Request a resource.

impl Pool<ImageInfo, Image> for HashPool

fn resource(&mut self, info: ImageInfo) -> Result<Lease<Image>, DriverError>

Request a resource.

impl Pool<ImageInfo, Image> for LazyPool

fn resource(&mut self, info: ImageInfo) -> Result<Lease<Image>, DriverError>

Request a resource.

impl Resource for Image

type Node = ImageNode

The resource handle type.