Struct vulkano::pipeline::cache::PipelineCache

pub struct PipelineCache { /* private fields */ }

Opaque cache that contains pipeline objects.

See the documentation of the module for more info.

Implementations

impl PipelineCache

pub unsafe fn new( device: Arc<Device>, create_info: PipelineCacheCreateInfo ) -> Result<Arc<PipelineCache>, Validated<VulkanError>>

Builds a new pipeline cache.

Safety

• The data in create_info.initial_data must be valid data that was previously retrieved using get_data.

Examples

This example loads a cache from a file, if it exists. See get_data for how to store the data in a file.

use std::fs::File;
use std::io::Read;
use vulkano::pipeline::cache::{PipelineCache, PipelineCacheCreateInfo};

let initial_data = {
    let file = File::open("pipeline_cache.bin");
    if let Ok(mut file) = file {
        let mut data = Vec::new();
        if let Ok(_) = file.read_to_end(&mut data) {
            data
        } else {
            Vec::new()
        }
    } else {
        Vec::new()
    }
};

// This is unsafe because there is no way to be sure that the file contains valid data.
let cache = unsafe {
    PipelineCache::new(
        device.clone(),
        PipelineCacheCreateInfo {
            initial_data,
            ..Default::default()
        }
    ).unwrap()
};

pub unsafe fn from_handle( device: Arc<Device>, handle: PipelineCache, create_info: PipelineCacheCreateInfo ) -> Arc<PipelineCache>

Creates a new PipelineCache from a raw object handle.

Safety

• handle must be a valid Vulkan object handle created from device.
• create_info must match the info used to create the object.

pub fn flags(&self) -> PipelineCacheCreateFlags

Returns the flags that the pipeline cache was created with.

pub fn get_data(&self) -> Result<Vec<u8>, VulkanError>

Obtains the data from the cache.

This data can be stored and then reloaded and passed to PipelineCache::new.

Examples

use std::fs;
use std::fs::File;
use std::io::Write;

// If an error happens (eg. no permission for the file) we simply skip storing the cache.
if let Ok(data) = cache.get_data() {
    if let Ok(mut file) = File::create("pipeline_cache.bin.tmp") {
        if let Ok(_) = file.write_all(&data) {
            let _ = fs::rename("pipeline_cache.bin.tmp", "pipeline_cache.bin");
        } else {
            let _ = fs::remove_file("pipeline_cache.bin.tmp");
        }
    }
}

pub fn merge<'a>( &self, src_caches: impl IntoIterator<Item = &'a PipelineCache> ) -> Result<(), Validated<VulkanError>>

Merges other pipeline caches into this one.

It is self that is modified here. The pipeline caches passed as parameter are untouched.

Trait Implementations

impl Debug for PipelineCache

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

Formats the value using the given formatter.

impl DeviceOwned for PipelineCache

fn device(&self) -> &Arc<Device>

Returns the device that owns self.

impl Drop for PipelineCache

fn drop(&mut self)

Executes the destructor for this type.

impl Hash for PipelineCache

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PipelineCache

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

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

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

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

impl VulkanObject for PipelineCache

type Handle = PipelineCache

The type of the object.

fn handle(&self) -> Self::Handle

Returns the raw Vulkan handle of the object.

impl Eq for PipelineCache