1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// Generated by `scripts/generate_vk.js`

use utils::c_bindings::*;
use utils::vk_traits::*;
use utils::vk_ptr::*;
use utils::vk_convert::*;
use std::os::raw::c_char;
use std::ptr;
use std::mem;
use std::cmp;
use vk::*;

pub type RawVkPipelineCache = u64;

#[derive(Debug, Copy, Clone)]
pub struct VkPipelineCache {
    _handle: RawVkPipelineCache,
    _parent_instance: RawVkInstance,
    _parent_device: RawVkDevice,
    _fn_table: *mut VkInstanceFunctionTable
}

impl VkRawType<VkPipelineCache> for RawVkPipelineCache {
    fn vk_to_wrapped(src: &RawVkPipelineCache) -> VkPipelineCache {
        VkPipelineCache {
            _handle: *src,
            _parent_instance: 0,
            _parent_device: 0,
            _fn_table: ptr::null_mut()
        }
    }
}

impl VkWrappedType<RawVkPipelineCache> for VkPipelineCache {
    fn vk_to_raw(src: &VkPipelineCache, dst: &mut RawVkPipelineCache) {
        *dst = src._handle
    }
}

impl Default for VkPipelineCache {
    fn default() -> VkPipelineCache {
        VkPipelineCache {
            _handle: 0,
            _parent_instance: 0,
            _parent_device: 0,
            _fn_table: ptr::null_mut()
        }
    }
}

impl VkSetup for VkPipelineCache {
    fn vk_setup(&mut self, fn_table: *mut VkInstanceFunctionTable, instance: RawVkInstance, device: RawVkDevice) {
        self._parent_instance = instance;
        self._parent_device = device;
        self._fn_table = fn_table;
    }
}

impl VkPipelineCache {
    
    pub fn handle(&self) -> u64 {
        self._handle
    }
    
    pub fn destroy(&self) {
        unsafe {
            ((&*self._fn_table).vkDestroyPipelineCache)(self._parent_device, self._handle, ptr::null());
        }
    }
    
    pub fn get_data(&self) -> Result<Vec<c_void>, VkResult> {
        unsafe {
            let mut raw_data : *mut c_void = ptr::null_mut();
            let raw_data_size = &mut mem::uninitialized() as *mut usize;
            let vk_result = ((&*self._fn_table).vkGetPipelineCacheData)(self._parent_device, self._handle, raw_data_size, raw_data);
            if vk_result != 0 { return Err(RawVkResult::vk_to_wrapped(&vk_result)) }
            raw_data = malloc((*raw_data_size as usize) * mem::size_of::<c_void>()) as *mut c_void;
            
            let vk_result = ((&*self._fn_table).vkGetPipelineCacheData)(self._parent_device, self._handle, raw_data_size, raw_data);
            if vk_result != 0 { return Err(RawVkResult::vk_to_wrapped(&vk_result)) }
            
            let data = Vec::from_raw_parts(raw_data, *raw_data_size, *raw_data_size);
            Ok(data)
        }
    }
    
    pub fn merges(&self, src_caches: &[VkPipelineCache]) -> VkResult {
        unsafe {
            let raw_src_cache_count = src_caches.len() as u32;
            let raw_src_caches = new_ptr_vk_array(src_caches);
            let vk_result = ((&*self._fn_table).vkMergePipelineCaches)(self._parent_device, self._handle, raw_src_cache_count, raw_src_caches);
            free_ptr(raw_src_caches);
            RawVkResult::vk_to_wrapped(&vk_result)
        }
    }
    
    pub fn create_graphics_pipelines(&self, create_infos: &[VkGraphicsPipelineCreateInfo]) -> Result<Vec<VkPipeline>, VkResult> {
        unsafe {
            let raw_create_info_count = create_infos.len() as u32;
            let raw_create_infos = new_ptr_vk_array(create_infos);
            let raw_pipelines = malloc((raw_create_info_count as usize) * mem::size_of::<RawVkPipeline>()) as *mut RawVkPipeline;
            
            let vk_result = ((&*self._fn_table).vkCreateGraphicsPipelines)(self._parent_device, self._handle, raw_create_info_count, raw_create_infos, ptr::null(), raw_pipelines);
            if vk_result != 0 { return Err(RawVkResult::vk_to_wrapped(&vk_result)) }
            
            let mut pipelines = new_vk_array(raw_create_info_count, raw_pipelines);
            for elt in &mut pipelines { VkSetup::vk_setup(elt, self._fn_table, self._parent_instance, self._parent_device); }
            free_vk_ptr_array(raw_create_info_count as usize, raw_create_infos);
            free_ptr(raw_pipelines);
            Ok(pipelines)
        }
    }
    
    pub fn create_compute_pipelines(&self, create_infos: &[VkComputePipelineCreateInfo]) -> Result<Vec<VkPipeline>, VkResult> {
        unsafe {
            let raw_create_info_count = create_infos.len() as u32;
            let raw_create_infos = new_ptr_vk_array(create_infos);
            let raw_pipelines = malloc((raw_create_info_count as usize) * mem::size_of::<RawVkPipeline>()) as *mut RawVkPipeline;
            
            let vk_result = ((&*self._fn_table).vkCreateComputePipelines)(self._parent_device, self._handle, raw_create_info_count, raw_create_infos, ptr::null(), raw_pipelines);
            if vk_result != 0 { return Err(RawVkResult::vk_to_wrapped(&vk_result)) }
            
            let mut pipelines = new_vk_array(raw_create_info_count, raw_pipelines);
            for elt in &mut pipelines { VkSetup::vk_setup(elt, self._fn_table, self._parent_instance, self._parent_device); }
            free_vk_ptr_array(raw_create_info_count as usize, raw_create_infos);
            free_ptr(raw_pipelines);
            Ok(pipelines)
        }
    }
}