Struct vulkanic::DevicePointers[][src]

pub struct DevicePointers { /* fields omitted */ }

Wrapper for vk::DevicePointers.

Implementations

impl DevicePointers[src]

pub fn new(ptr: DevicePointers) -> Self[src]

Create new vk::DevicePointers wrapper.

pub fn into_inner(self) -> DevicePointers[src]

Unwraps vk::DevicePointers.

pub fn destroy_device(&self, device: Device)[src]

pub fn get_device_queue(
    &self,
    device: Device,
    queue_family_index: u32,
    queue_index: u32
) -> Queue
[src]

pub unsafe fn queue_submit(
    &self,
    queue: Queue,
    submits: &[SubmitInfo],
    fence: Fence
) -> Result<()>
[src]

pub fn queue_wait_idle(&self, queue: Queue) -> Result<()>[src]

pub fn device_wait_idle(&self, device: Device) -> Result<()>[src]

pub unsafe fn allocate_memory(
    &self,
    device: Device,
    allocate_info: &MemoryAllocateInfo
) -> Result<DeviceMemory>
[src]

https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateMemory.html

Safety

allocate_info should be valid regarding its containing pointers.

pub fn free_memory(&self, device: Device, memory: DeviceMemory)[src]

pub fn map_memory(
    &self,
    device: Device,
    memory: DeviceMemory,
    offset: DeviceSize,
    size: DeviceSize,
    flags: MemoryMapFlags
) -> Result<*mut c_void>
[src]

pub fn unmap_memory(&self, device: Device, memory: DeviceMemory)[src]

pub fn bind_buffer_memory(
    &self,
    device: Device,
    buffer: Buffer,
    memory: DeviceMemory,
    memory_offset: DeviceSize
) -> Result<()>
[src]

pub fn get_buffer_memory_requirements(
    &self,
    device: Device,
    buffer: Buffer
) -> MemoryRequirements
[src]

pub unsafe fn create_fence(
    &self,
    device: Device,
    create_info: &FenceCreateInfo
) -> Result<Fence>
[src]

https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateFence.html

Safety

create_info should be valid regarding its containing pointers.

pub fn destroy_fence(&self, device: Device, fence: Fence)[src]

pub fn reset_fences(&self, device: Device, fences: &[Fence]) -> Result<()>[src]

pub fn wait_for_fences(
    &self,
    device: Device,
    fences: &[Fence],
    wait_all: bool,
    timeout: u64
) -> Result<()>
[src]

pub unsafe fn create_semaphore(
    &self,
    device: Device,
    create_info: &SemaphoreCreateInfo
) -> Result<Semaphore>
[src]

pub fn destroy_semaphore(&self, device: Device, semaphore: Semaphore)[src]

pub unsafe fn create_buffer(
    &self,
    device: Device,
    create_info: &BufferCreateInfo
) -> Result<Buffer>
[src]

https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateBuffer.html

Safety

create_info should be valid regarding its containing pointers.

pub fn destroy_buffer(&self, device: Device, buffer: Buffer)[src]

pub unsafe fn create_image_view(
    &self,
    device: Device,
    create_info: &ImageViewCreateInfo
) -> Result<ImageView>
[src]

pub fn destroy_image_view(&self, device: Device, image_view: ImageView)[src]

pub unsafe fn create_shader_module(
    &self,
    device: Device,
    create_info: &ShaderModuleCreateInfo
) -> Result<ShaderModule>
[src]

pub fn destroy_shader_module(&self, device: Device, shader_module: ShaderModule)[src]

pub unsafe fn create_graphics_pipelines(
    &self,
    device: Device,
    pipeline_cache: PipelineCache,
    create_infos: &[GraphicsPipelineCreateInfo]
) -> Result<Vec<Pipeline>>
[src]

pub fn destroy_pipeline(&self, device: Device, pipeline: Pipeline)[src]

pub unsafe fn create_pipeline_layout(
    &self,
    device: Device,
    create_info: &PipelineLayoutCreateInfo
) -> Result<PipelineLayout>
[src]

pub fn destroy_pipeline_layout(
    &self,
    device: Device,
    pipeline_layout: PipelineLayout
)
[src]

pub unsafe fn create_framebuffer(
    &self,
    device: Device,
    create_info: &FramebufferCreateInfo
) -> Result<Framebuffer>
[src]

pub fn destroy_framebuffer(&self, device: Device, framebuffer: Framebuffer)[src]

pub unsafe fn create_render_pass(
    &self,
    device: Device,
    create_info: &RenderPassCreateInfo
) -> Result<RenderPass>
[src]

pub fn destroy_render_pass(&self, device: Device, render_pass: RenderPass)[src]

pub unsafe fn create_command_pool(
    &self,
    device: Device,
    create_info: &CommandPoolCreateInfo
) -> Result<CommandPool>
[src]

pub fn destroy_command_pool(&self, device: Device, command_pool: CommandPool)[src]

pub unsafe fn allocate_command_buffers(
    &self,
    device: Device,
    allocate_info: &CommandBufferAllocateInfo
) -> Result<Vec<CommandBuffer>>
[src]

https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateCommandBuffers.html

Will read allocate_info.commandBufferCount for size of the return vector.

Safety

allocate_info should be valid regarding its containing pointers.

pub fn free_command_buffers(
    &self,
    device: Device,
    command_pool: CommandPool,
    command_buffers: &[CommandBuffer]
)
[src]

pub unsafe fn begin_command_buffer(
    &self,
    command_buffer: CommandBuffer,
    begin_info: &CommandBufferBeginInfo
) -> Result<()>
[src]

pub fn end_command_buffer(&self, command_buffer: CommandBuffer) -> Result<()>[src]

pub fn reset_command_buffer(
    &self,
    command_buffer: CommandBuffer,
    flags: CommandBufferResetFlags
) -> Result<()>
[src]

pub fn cmd_bind_pipeline(
    &self,
    command_buffer: CommandBuffer,
    pipeline_bind_point: PipelineBindPoint,
    pipeline: Pipeline
)
[src]

pub fn cmd_bind_vertex_buffers(
    &self,
    command_buffer: CommandBuffer,
    first_binding: u32,
    buffers: &[Buffer],
    offsets: &[DeviceSize]
)
[src]

pub fn cmd_draw(
    &self,
    command_buffer: CommandBuffer,
    vertex_count: u32,
    instance_count: u32,
    first_vertex: u32,
    first_instance: u32
)
[src]

pub unsafe fn cmd_begin_render_pass(
    &self,
    command_buffer: CommandBuffer,
    render_pass_begin: &RenderPassBeginInfo,
    contents: SubpassContents
)
[src]

https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass.html

Safety

render_pass_begin should be valid regarding its containing pointers.

pub fn cmd_end_render_pass(&self, command_buffer: CommandBuffer)[src]

pub unsafe fn create_swapchain_khr(
    &self,
    device: Device,
    create_info: &SwapchainCreateInfoKHR
) -> Result<SwapchainKHR>
[src]

pub fn destroy_swapchain_khr(&self, device: Device, swapchain: SwapchainKHR)[src]

pub fn get_swapchain_images_khr(
    &self,
    device: Device,
    swapchain: SwapchainKHR
) -> Result<Vec<Image>>
[src]

pub fn acquire_next_image_khr(
    &self,
    device: Device,
    swapchain: SwapchainKHR,
    timeout: u64,
    semaphore: Semaphore,
    fence: Fence
) -> Result<u32>
[src]

pub unsafe fn queue_present_khr(
    &self,
    queue: Queue,
    present_info: &PresentInfoKHR
) -> Result<()>
[src]

https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueuePresentKHR.html

Safety

present_info should be valid regarding its containing pointers.

Methods from Deref<Target = DevicePointers>

pub unsafe fn DestroyDevice(
    &self,
    device: usize,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn GetDeviceQueue(
    &self,
    device: usize,
    queueFamilyIndex: u32,
    queueIndex: u32,
    pQueue: *mut usize
)
[src]

pub unsafe fn QueueSubmit(
    &self,
    queue: usize,
    submitCount: u32,
    pSubmits: *const SubmitInfo,
    fence: u64
) -> u32
[src]

pub unsafe fn QueueWaitIdle(&self, queue: usize) -> u32[src]

pub unsafe fn DeviceWaitIdle(&self, device: usize) -> u32[src]

pub unsafe fn AllocateMemory(
    &self,
    device: usize,
    pAllocateInfo: *const MemoryAllocateInfo,
    pAllocator: *const AllocationCallbacks,
    pMemory: *mut u64
) -> u32
[src]

pub unsafe fn FreeMemory(
    &self,
    device: usize,
    memory: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn MapMemory(
    &self,
    device: usize,
    memory: u64,
    offset: u64,
    size: u64,
    flags: u32,
    ppData: *mut *mut c_void
) -> u32
[src]

pub unsafe fn UnmapMemory(&self, device: usize, memory: u64)[src]

pub unsafe fn FlushMappedMemoryRanges(
    &self,
    device: usize,
    memoryRangeCount: u32,
    pMemoryRanges: *const MappedMemoryRange
) -> u32
[src]

pub unsafe fn InvalidateMappedMemoryRanges(
    &self,
    device: usize,
    memoryRangeCount: u32,
    pMemoryRanges: *const MappedMemoryRange
) -> u32
[src]

pub unsafe fn GetDeviceMemoryCommitment(
    &self,
    device: usize,
    memory: u64,
    pCommittedMemoryInBytes: *mut u64
)
[src]

pub unsafe fn BindBufferMemory(
    &self,
    device: usize,
    buffer: u64,
    memory: u64,
    memoryOffset: u64
) -> u32
[src]

pub unsafe fn BindImageMemory(
    &self,
    device: usize,
    image: u64,
    memory: u64,
    memoryOffset: u64
) -> u32
[src]

pub unsafe fn GetBufferMemoryRequirements(
    &self,
    device: usize,
    buffer: u64,
    pMemoryRequirements: *mut MemoryRequirements
)
[src]

pub unsafe fn GetImageMemoryRequirements(
    &self,
    device: usize,
    image: u64,
    pMemoryRequirements: *mut MemoryRequirements
)
[src]

pub unsafe fn GetImageSparseMemoryRequirements(
    &self,
    device: usize,
    image: u64,
    pSparseMemoryRequirementCount: *mut u32,
    pSparseMemoryRequirements: *mut SparseImageMemoryRequirements
)
[src]

pub unsafe fn QueueBindSparse(
    &self,
    queue: usize,
    bindInfoCount: u32,
    pBindInfo: *const BindSparseInfo,
    fence: u64
) -> u32
[src]

pub unsafe fn CreateFence(
    &self,
    device: usize,
    pCreateInfo: *const FenceCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pFence: *mut u64
) -> u32
[src]

pub unsafe fn DestroyFence(
    &self,
    device: usize,
    fence: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn ResetFences(
    &self,
    device: usize,
    fenceCount: u32,
    pFences: *const u64
) -> u32
[src]

pub unsafe fn GetFenceStatus(&self, device: usize, fence: u64) -> u32[src]

pub unsafe fn WaitForFences(
    &self,
    device: usize,
    fenceCount: u32,
    pFences: *const u64,
    waitAll: u32,
    timeout: u64
) -> u32
[src]

pub unsafe fn CreateSemaphore(
    &self,
    device: usize,
    pCreateInfo: *const SemaphoreCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pSemaphore: *mut u64
) -> u32
[src]

pub unsafe fn DestroySemaphore(
    &self,
    device: usize,
    semaphore: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn CreateEvent(
    &self,
    device: usize,
    pCreateInfo: *const EventCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pEvent: *mut u64
) -> u32
[src]

pub unsafe fn DestroyEvent(
    &self,
    device: usize,
    event: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn GetEventStatus(&self, device: usize, event: u64) -> u32[src]

pub unsafe fn SetEvent(&self, device: usize, event: u64) -> u32[src]

pub unsafe fn ResetEvent(&self, device: usize, event: u64) -> u32[src]

pub unsafe fn CreateQueryPool(
    &self,
    device: usize,
    pCreateInfo: *const QueryPoolCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pQueryPool: *mut u64
) -> u32
[src]

pub unsafe fn DestroyQueryPool(
    &self,
    device: usize,
    queryPool: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn GetQueryPoolResults(
    &self,
    device: usize,
    queryPool: u64,
    firstQuery: u32,
    queryCount: u32,
    dataSize: usize,
    pData: *mut c_void,
    stride: u64,
    flags: u32
) -> u32
[src]

pub unsafe fn CreateBuffer(
    &self,
    device: usize,
    pCreateInfo: *const BufferCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pBuffer: *mut u64
) -> u32
[src]

pub unsafe fn DestroyBuffer(
    &self,
    device: usize,
    buffer: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn CreateBufferView(
    &self,
    device: usize,
    pCreateInfo: *const BufferViewCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pView: *mut u64
) -> u32
[src]

pub unsafe fn DestroyBufferView(
    &self,
    device: usize,
    bufferView: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn CreateImage(
    &self,
    device: usize,
    pCreateInfo: *const ImageCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pImage: *mut u64
) -> u32
[src]

pub unsafe fn DestroyImage(
    &self,
    device: usize,
    image: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn GetImageSubresourceLayout(
    &self,
    device: usize,
    image: u64,
    pSubresource: *const ImageSubresource,
    pLayout: *mut SubresourceLayout
)
[src]

pub unsafe fn CreateImageView(
    &self,
    device: usize,
    pCreateInfo: *const ImageViewCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pView: *mut u64
) -> u32
[src]

pub unsafe fn DestroyImageView(
    &self,
    device: usize,
    imageView: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn CreateShaderModule(
    &self,
    device: usize,
    pCreateInfo: *const ShaderModuleCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pShaderModule: *mut u64
) -> u32
[src]

pub unsafe fn DestroyShaderModule(
    &self,
    device: usize,
    shaderModule: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn CreatePipelineCache(
    &self,
    device: usize,
    pCreateInfo: *const PipelineCacheCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pPipelineCache: *mut u64
) -> u32
[src]

pub unsafe fn DestroyPipelineCache(
    &self,
    device: usize,
    pipelineCache: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn GetPipelineCacheData(
    &self,
    device: usize,
    pipelineCache: u64,
    pDataSize: *mut usize,
    pData: *mut c_void
) -> u32
[src]

pub unsafe fn MergePipelineCaches(
    &self,
    device: usize,
    dstCache: u64,
    srcCacheCount: u32,
    pSrcCaches: *const u64
) -> u32
[src]

pub unsafe fn CreateGraphicsPipelines(
    &self,
    device: usize,
    pipelineCache: u64,
    createInfoCount: u32,
    pCreateInfos: *const GraphicsPipelineCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pPipelines: *mut u64
) -> u32
[src]

pub unsafe fn CreateComputePipelines(
    &self,
    device: usize,
    pipelineCache: u64,
    createInfoCount: u32,
    pCreateInfos: *const ComputePipelineCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pPipelines: *mut u64
) -> u32
[src]

pub unsafe fn DestroyPipeline(
    &self,
    device: usize,
    pipeline: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn CreatePipelineLayout(
    &self,
    device: usize,
    pCreateInfo: *const PipelineLayoutCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pPipelineLayout: *mut u64
) -> u32
[src]

pub unsafe fn DestroyPipelineLayout(
    &self,
    device: usize,
    pipelineLayout: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn CreateSampler(
    &self,
    device: usize,
    pCreateInfo: *const SamplerCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pSampler: *mut u64
) -> u32
[src]

pub unsafe fn DestroySampler(
    &self,
    device: usize,
    sampler: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn CreateDescriptorSetLayout(
    &self,
    device: usize,
    pCreateInfo: *const DescriptorSetLayoutCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pSetLayout: *mut u64
) -> u32
[src]

pub unsafe fn DestroyDescriptorSetLayout(
    &self,
    device: usize,
    descriptorSetLayout: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn CreateDescriptorPool(
    &self,
    device: usize,
    pCreateInfo: *const DescriptorPoolCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pDescriptorPool: *mut u64
) -> u32
[src]

pub unsafe fn DestroyDescriptorPool(
    &self,
    device: usize,
    descriptorPool: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn ResetDescriptorPool(
    &self,
    device: usize,
    descriptorPool: u64,
    flags: u32
) -> u32
[src]

pub unsafe fn AllocateDescriptorSets(
    &self,
    device: usize,
    pAllocateInfo: *const DescriptorSetAllocateInfo,
    pDescriptorSets: *mut u64
) -> u32
[src]

pub unsafe fn FreeDescriptorSets(
    &self,
    device: usize,
    descriptorPool: u64,
    descriptorSetCount: u32,
    pDescriptorSets: *const u64
) -> u32
[src]

pub unsafe fn UpdateDescriptorSets(
    &self,
    device: usize,
    descriptorWriteCount: u32,
    pDescriptorWrites: *const WriteDescriptorSet,
    descriptorCopyCount: u32,
    pDescriptorCopies: *const CopyDescriptorSet
)
[src]

pub unsafe fn CreateFramebuffer(
    &self,
    device: usize,
    pCreateInfo: *const FramebufferCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pFramebuffer: *mut u64
) -> u32
[src]

pub unsafe fn DestroyFramebuffer(
    &self,
    device: usize,
    framebuffer: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn CreateRenderPass(
    &self,
    device: usize,
    pCreateInfo: *const RenderPassCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pRenderPass: *mut u64
) -> u32
[src]

pub unsafe fn DestroyRenderPass(
    &self,
    device: usize,
    renderPass: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn GetRenderAreaGranularity(
    &self,
    device: usize,
    renderPass: u64,
    pGranularity: *mut Extent2D
)
[src]

pub unsafe fn CreateCommandPool(
    &self,
    device: usize,
    pCreateInfo: *const CommandPoolCreateInfo,
    pAllocator: *const AllocationCallbacks,
    pCommandPool: *mut u64
) -> u32
[src]

pub unsafe fn DestroyCommandPool(
    &self,
    device: usize,
    commandPool: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn ResetCommandPool(
    &self,
    device: usize,
    commandPool: u64,
    flags: u32
) -> u32
[src]

pub unsafe fn TrimCommandPoolKHR(
    &self,
    device: usize,
    commandPool: u64,
    flags: u32
)
[src]

pub unsafe fn AllocateCommandBuffers(
    &self,
    device: usize,
    pAllocateInfo: *const CommandBufferAllocateInfo,
    pCommandBuffers: *mut usize
) -> u32
[src]

pub unsafe fn FreeCommandBuffers(
    &self,
    device: usize,
    commandPool: u64,
    commandBufferCount: u32,
    pCommandBuffers: *const usize
)
[src]

pub unsafe fn BeginCommandBuffer(
    &self,
    commandBuffer: usize,
    pBeginInfo: *const CommandBufferBeginInfo
) -> u32
[src]

pub unsafe fn EndCommandBuffer(&self, commandBuffer: usize) -> u32[src]

pub unsafe fn ResetCommandBuffer(&self, commandBuffer: usize, flags: u32) -> u32[src]

pub unsafe fn CmdBindPipeline(
    &self,
    commandBuffer: usize,
    pipelineBindPoint: u32,
    pipeline: u64
)
[src]

pub unsafe fn CmdSetViewport(
    &self,
    commandBuffer: usize,
    firstViewport: u32,
    viewportCount: u32,
    pViewports: *const Viewport
)
[src]

pub unsafe fn CmdSetScissor(
    &self,
    commandBuffer: usize,
    firstScissor: u32,
    scissorCount: u32,
    pScissors: *const Rect2D
)
[src]

pub unsafe fn CmdSetLineWidth(&self, commandBuffer: usize, lineWidth: f32)[src]

pub unsafe fn CmdSetDepthBias(
    &self,
    commandBuffer: usize,
    depthBiasConstantFactor: f32,
    depthBiasClamp: f32,
    depthBiasSlopeFactor: f32
)
[src]

pub unsafe fn CmdSetBlendConstants(
    &self,
    commandBuffer: usize,
    blendConstants: &[f32; 4]
)
[src]

pub unsafe fn CmdSetDepthBounds(
    &self,
    commandBuffer: usize,
    minDepthBounds: f32,
    maxDepthBounds: f32
)
[src]

pub unsafe fn CmdSetStencilCompareMask(
    &self,
    commandBuffer: usize,
    faceMask: u32,
    compareMask: u32
)
[src]

pub unsafe fn CmdSetStencilWriteMask(
    &self,
    commandBuffer: usize,
    faceMask: u32,
    writeMask: u32
)
[src]

pub unsafe fn CmdSetStencilReference(
    &self,
    commandBuffer: usize,
    faceMask: u32,
    reference: u32
)
[src]

pub unsafe fn CmdBindDescriptorSets(
    &self,
    commandBuffer: usize,
    pipelineBindPoint: u32,
    layout: u64,
    firstSet: u32,
    descriptorSetCount: u32,
    pDescriptorSets: *const u64,
    dynamicOffsetCount: u32,
    pDynamicOffsets: *const u32
)
[src]

pub unsafe fn CmdBindIndexBuffer(
    &self,
    commandBuffer: usize,
    buffer: u64,
    offset: u64,
    indexType: u32
)
[src]

pub unsafe fn CmdBindVertexBuffers(
    &self,
    commandBuffer: usize,
    firstBinding: u32,
    bindingCount: u32,
    pBuffers: *const u64,
    pOffsets: *const u64
)
[src]

pub unsafe fn CmdDraw(
    &self,
    commandBuffer: usize,
    vertexCount: u32,
    instanceCount: u32,
    firstVertex: u32,
    firstInstance: u32
)
[src]

pub unsafe fn CmdDrawIndexed(
    &self,
    commandBuffer: usize,
    indexCount: u32,
    instanceCount: u32,
    firstIndex: u32,
    vertexOffset: i32,
    firstInstance: u32
)
[src]

pub unsafe fn CmdDrawIndirect(
    &self,
    commandBuffer: usize,
    buffer: u64,
    offset: u64,
    drawCount: u32,
    stride: u32
)
[src]

pub unsafe fn CmdDrawIndexedIndirect(
    &self,
    commandBuffer: usize,
    buffer: u64,
    offset: u64,
    drawCount: u32,
    stride: u32
)
[src]

pub unsafe fn CmdDispatch(&self, commandBuffer: usize, x: u32, y: u32, z: u32)[src]

pub unsafe fn CmdDispatchIndirect(
    &self,
    commandBuffer: usize,
    buffer: u64,
    offset: u64
)
[src]

pub unsafe fn CmdCopyBuffer(
    &self,
    commandBuffer: usize,
    srcBuffer: u64,
    dstBuffer: u64,
    regionCount: u32,
    pRegions: *const BufferCopy
)
[src]

pub unsafe fn CmdCopyImage(
    &self,
    commandBuffer: usize,
    srcImage: u64,
    srcImageLayout: u32,
    dstImage: u64,
    dstImageLayout: u32,
    regionCount: u32,
    pRegions: *const ImageCopy
)
[src]

pub unsafe fn CmdBlitImage(
    &self,
    commandBuffer: usize,
    srcImage: u64,
    srcImageLayout: u32,
    dstImage: u64,
    dstImageLayout: u32,
    regionCount: u32,
    pRegions: *const ImageBlit,
    filter: u32
)
[src]

pub unsafe fn CmdCopyBufferToImage(
    &self,
    commandBuffer: usize,
    srcBuffer: u64,
    dstImage: u64,
    dstImageLayout: u32,
    regionCount: u32,
    pRegions: *const BufferImageCopy
)
[src]

pub unsafe fn CmdCopyImageToBuffer(
    &self,
    commandBuffer: usize,
    srcImage: u64,
    srcImageLayout: u32,
    dstBuffer: u64,
    regionCount: u32,
    pRegions: *const BufferImageCopy
)
[src]

pub unsafe fn CmdUpdateBuffer(
    &self,
    commandBuffer: usize,
    dstBuffer: u64,
    dstOffset: u64,
    dataSize: u64,
    pData: *const u32
)
[src]

pub unsafe fn CmdFillBuffer(
    &self,
    commandBuffer: usize,
    dstBuffer: u64,
    dstOffset: u64,
    size: u64,
    data: u32
)
[src]

pub unsafe fn CmdClearColorImage(
    &self,
    commandBuffer: usize,
    image: u64,
    imageLayout: u32,
    pColor: *const ClearColorValue,
    rangeCount: u32,
    pRanges: *const ImageSubresourceRange
)
[src]

pub unsafe fn CmdClearDepthStencilImage(
    &self,
    commandBuffer: usize,
    image: u64,
    imageLayout: u32,
    pDepthStencil: *const ClearDepthStencilValue,
    rangeCount: u32,
    pRanges: *const ImageSubresourceRange
)
[src]

pub unsafe fn CmdClearAttachments(
    &self,
    commandBuffer: usize,
    attachmentCount: u32,
    pAttachments: *const ClearAttachment,
    rectCount: u32,
    pRects: *const ClearRect
)
[src]

pub unsafe fn CmdResolveImage(
    &self,
    commandBuffer: usize,
    srcImage: u64,
    srcImageLayout: u32,
    dstImage: u64,
    dstImageLayout: u32,
    regionCount: u32,
    pRegions: *const ImageResolve
)
[src]

pub unsafe fn CmdSetEvent(
    &self,
    commandBuffer: usize,
    event: u64,
    stageMask: u32
)
[src]

pub unsafe fn CmdResetEvent(
    &self,
    commandBuffer: usize,
    event: u64,
    stageMask: u32
)
[src]

pub unsafe fn CmdWaitEvents(
    &self,
    commandBuffer: usize,
    eventCount: u32,
    pEvents: *const u64,
    srcStageMask: u32,
    dstStageMask: u32,
    memoryBarrierCount: u32,
    pMemoryBarriers: *const MemoryBarrier,
    bufferMemoryBarrierCount: u32,
    pBufferMemoryBarriers: *const BufferMemoryBarrier,
    imageMemoryBarrierCount: u32,
    pImageMemoryBarriers: *const ImageMemoryBarrier
)
[src]

pub unsafe fn CmdPipelineBarrier(
    &self,
    commandBuffer: usize,
    srcStageMask: u32,
    dstStageMask: u32,
    dependencyFlags: u32,
    memoryBarrierCount: u32,
    pMemoryBarriers: *const MemoryBarrier,
    bufferMemoryBarrierCount: u32,
    pBufferMemoryBarriers: *const BufferMemoryBarrier,
    imageMemoryBarrierCount: u32,
    pImageMemoryBarriers: *const ImageMemoryBarrier
)
[src]

pub unsafe fn CmdBeginQuery(
    &self,
    commandBuffer: usize,
    queryPool: u64,
    query: u32,
    flags: u32
)
[src]

pub unsafe fn CmdEndQuery(
    &self,
    commandBuffer: usize,
    queryPool: u64,
    query: u32
)
[src]

pub unsafe fn CmdResetQueryPool(
    &self,
    commandBuffer: usize,
    queryPool: u64,
    firstQuery: u32,
    queryCount: u32
)
[src]

pub unsafe fn CmdWriteTimestamp(
    &self,
    commandBuffer: usize,
    pipelineStage: u32,
    queryPool: u64,
    query: u32
)
[src]

pub unsafe fn CmdCopyQueryPoolResults(
    &self,
    commandBuffer: usize,
    queryPool: u64,
    firstQuery: u32,
    queryCount: u32,
    dstBuffer: u64,
    dstOffset: u64,
    stride: u64,
    flags: u32
)
[src]

pub unsafe fn CmdPushConstants(
    &self,
    commandBuffer: usize,
    layout: u64,
    stageFlags: u32,
    offset: u32,
    size: u32,
    pValues: *const c_void
)
[src]

pub unsafe fn CmdBeginRenderPass(
    &self,
    commandBuffer: usize,
    pRenderPassBegin: *const RenderPassBeginInfo,
    contents: u32
)
[src]

pub unsafe fn CmdNextSubpass(&self, commandBuffer: usize, contents: u32)[src]

pub unsafe fn CmdEndRenderPass(&self, commandBuffer: usize)[src]

pub unsafe fn CmdExecuteCommands(
    &self,
    commandBuffer: usize,
    commandBufferCount: u32,
    pCommandBuffers: *const usize
)
[src]

pub unsafe fn CreateSwapchainKHR(
    &self,
    device: usize,
    pCreateInfo: *const SwapchainCreateInfoKHR,
    pAllocator: *const AllocationCallbacks,
    pSwapchain: *mut u64
) -> u32
[src]

pub unsafe fn DestroySwapchainKHR(
    &self,
    device: usize,
    swapchain: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn GetSwapchainImagesKHR(
    &self,
    device: usize,
    swapchain: u64,
    pSwapchainImageCount: *mut u32,
    pSwapchainImages: *mut u64
) -> u32
[src]

pub unsafe fn AcquireNextImageKHR(
    &self,
    device: usize,
    swapchain: u64,
    timeout: u64,
    semaphore: u64,
    fence: u64,
    pImageIndex: *mut u32
) -> u32
[src]

pub unsafe fn QueuePresentKHR(
    &self,
    queue: usize,
    pPresentInfo: *const PresentInfoKHR
) -> u32
[src]

pub unsafe fn CreateSharedSwapchainsKHR(
    &self,
    device: usize,
    swapchainCount: u32,
    pCreateInfos: *const SwapchainCreateInfoKHR,
    pAllocator: *const AllocationCallbacks,
    pSwapchains: *mut u64
) -> u32
[src]

pub unsafe fn CmdPushDescriptorSetKHR(
    &self,
    commandBuffer: usize,
    pipelineBindPoint: u32,
    layout: u64,
    set: u32,
    descriptorWriteCount: u32,
    pDescriptorWrites: *const WriteDescriptorSet
)
[src]

pub unsafe fn CreateDescriptorUpdateTemplateKHR(
    &self,
    device: usize,
    pCreateInfo: *const DescriptorUpdateTemplateCreateInfoKHR,
    pAllocator: *const AllocationCallbacks,
    pDescriptorUpdateTemplate: *mut u64
) -> u32
[src]

pub unsafe fn DestroyDescriptorUpdateTemplateKHR(
    &self,
    device: usize,
    descriptorUpdateTemplate: u64,
    pAllocator: *const AllocationCallbacks
)
[src]

pub unsafe fn UpdateDescriptorSetWithTemplateKHR(
    &self,
    device: usize,
    descriptorSet: u64,
    descriptorUpdateTemplate: u64,
    pData: *const c_void
)
[src]

pub unsafe fn CmdPushDescriptorSetWithTemplateKHR(
    &self,
    commandBuffer: usize,
    descriptorUpdateTemplate: u64,
    layout: u64,
    set: u32,
    pData: *const c_void
)
[src]

pub unsafe fn GetImageMemoryRequirements2KHR(
    &self,
    device: usize,
    pInfo: *const ImageMemoryRequirementsInfo2KHR,
    pMemoryRequirements: *mut MemoryRequirements2KHR
)
[src]

pub unsafe fn GetBufferMemoryRequirements2KHR(
    &self,
    device: usize,
    pInfo: *const BufferMemoryRequirementsInfo2KHR,
    pMemoryRequirements: *mut MemoryRequirements2KHR
)
[src]

pub unsafe fn SetDebugUtilsObjectNameEXT(
    &self,
    device: usize,
    pNameInfo: *const DebugUtilsObjectNameInfoEXT
) -> u32
[src]

pub unsafe fn CmdBeginDebugUtilsLabelEXT(
    &self,
    commandBuffer: usize,
    pLabelInfo: *const DebugUtilsLabelEXT
) -> u32
[src]

pub unsafe fn CmdEndDebugUtilsLabelEXT(&self, commandBuffer: usize) -> u32[src]

pub unsafe fn CmdInsertDebugUtilsLabelEXT(
    &self,
    commandBuffer: usize,
    pLabelInfo: *const DebugUtilsLabelEXT
) -> u32
[src]

pub unsafe fn AcquireFullScreenExclusiveModeEXT(
    &self,
    device: usize,
    swapchain: u64
) -> u32
[src]

pub unsafe fn ReleaseFullScreenExclusiveModeEXT(
    &self,
    device: usize,
    swapchain: u64
) -> u32
[src]

pub unsafe fn GetBufferDeviceAddressEXT(
    &self,
    device: usize,
    pInfo: *const BufferDeviceAddressInfo
) -> u64
[src]

Trait Implementations

impl Deref for DevicePointers[src]

type Target = DevicePointers

The resulting type after dereferencing.

impl<T: Into<DevicePointers>> From<T> for DevicePointers[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.