Struct ash::vk::cmds::DeviceFnV1_0

pub struct DeviceFnV1_0 { /* fields omitted */ }

Methods

impl DeviceFnV1_0

fn load<F>(f: F) -> Result<DeviceFnV1_0, Vec<&'static str>> where
    F: FnMut(&CStr) -> *const c_void, 

unsafe fn destroy_device(
    &self,
    device: Device,
    p_allocator: *const AllocationCallbacks
)

unsafe fn get_device_queue(
    &self,
    device: Device,
    queue_family_index: uint32_t,
    queue_index: uint32_t,
    p_queue: *mut Queue
)

unsafe fn queue_submit(
    &self,
    queue: Queue,
    submit_count: uint32_t,
    p_submits: *const SubmitInfo,
    fence: Fence
) -> Result

unsafe fn queue_wait_idle(&self, queue: Queue) -> Result

unsafe fn device_wait_idle(&self, device: Device) -> Result

unsafe fn allocate_memory(
    &self,
    device: Device,
    p_allocate_info: *const MemoryAllocateInfo,
    p_allocator: *const AllocationCallbacks,
    p_memory: *mut DeviceMemory
) -> Result

unsafe fn free_memory(
    &self,
    device: Device,
    memory: DeviceMemory,
    p_allocator: *const AllocationCallbacks
)

unsafe fn map_memory(
    &self,
    device: Device,
    memory: DeviceMemory,
    offset: DeviceSize,
    size: DeviceSize,
    flags: MemoryMapFlags,
    pp_data: *mut *mut c_void
) -> Result

unsafe fn unmap_memory(&self, device: Device, memory: DeviceMemory)

unsafe fn flush_mapped_memory_ranges(
    &self,
    device: Device,
    memory_range_count: uint32_t,
    p_memory_ranges: *const MappedMemoryRange
) -> Result

unsafe fn invalidate_mapped_memory_ranges(
    &self,
    device: Device,
    memory_range_count: uint32_t,
    p_memory_ranges: *const MappedMemoryRange
) -> Result

unsafe fn get_device_memory_commitment(
    &self,
    device: Device,
    memory: DeviceMemory,
    p_committed_memory_in_bytes: *mut DeviceSize
)

unsafe fn bind_buffer_memory(
    &self,
    device: Device,
    buffer: Buffer,
    memory: DeviceMemory,
    memory_offset: DeviceSize
) -> Result

unsafe fn bind_image_memory(
    &self,
    device: Device,
    image: Image,
    memory: DeviceMemory,
    memory_offset: DeviceSize
) -> Result

unsafe fn get_buffer_memory_requirements(
    &self,
    device: Device,
    buffer: Buffer,
    p_memory_requirements: *mut MemoryRequirements
)

unsafe fn get_image_memory_requirements(
    &self,
    device: Device,
    image: Image,
    p_memory_requirements: *mut MemoryRequirements
)

unsafe fn get_image_sparse_memory_requirements(
    &self,
    device: Device,
    image: Image,
    p_sparse_memory_requirement_count: *mut uint32_t,
    p_sparse_memory_requirements: *mut SparseImageMemoryRequirements
)

unsafe fn queue_bind_sparse(
    &self,
    queue: Queue,
    bind_info_count: uint32_t,
    p_bind_info: *const BindSparseInfo,
    fence: Fence
) -> Result

unsafe fn create_fence(
    &self,
    device: Device,
    p_create_info: *const FenceCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_fence: *mut Fence
) -> Result

unsafe fn destroy_fence(
    &self,
    device: Device,
    fence: Fence,
    p_allocator: *const AllocationCallbacks
)

unsafe fn reset_fences(
    &self,
    device: Device,
    fence_count: uint32_t,
    p_fences: *const Fence
) -> Result

unsafe fn get_fence_status(&self, device: Device, fence: Fence) -> Result

unsafe fn wait_for_fences(
    &self,
    device: Device,
    fence_count: uint32_t,
    p_fences: *const Fence,
    wait_all: Bool32,
    timeout: uint64_t
) -> Result

unsafe fn create_semaphore(
    &self,
    device: Device,
    p_create_info: *const SemaphoreCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_semaphore: *mut Semaphore
) -> Result

unsafe fn destroy_semaphore(
    &self,
    device: Device,
    semaphore: Semaphore,
    p_allocator: *const AllocationCallbacks
)

unsafe fn create_event(
    &self,
    device: Device,
    p_create_info: *const EventCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_event: *mut Event
) -> Result

unsafe fn destroy_event(
    &self,
    device: Device,
    event: Event,
    p_allocator: *const AllocationCallbacks
)

unsafe fn get_event_status(&self, device: Device, event: Event) -> Result

unsafe fn set_event(&self, device: Device, event: Event) -> Result

unsafe fn reset_event(&self, device: Device, event: Event) -> Result

unsafe fn create_query_pool(
    &self,
    device: Device,
    p_create_info: *const QueryPoolCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_query_pool: *mut QueryPool
) -> Result

unsafe fn destroy_query_pool(
    &self,
    device: Device,
    query_pool: QueryPool,
    p_allocator: *const AllocationCallbacks
)

unsafe fn get_query_pool_results(
    &self,
    device: Device,
    query_pool: QueryPool,
    first_query: uint32_t,
    query_count: uint32_t,
    data_size: size_t,
    p_data: *mut c_void,
    stride: DeviceSize,
    flags: QueryResultFlags
) -> Result

unsafe fn create_buffer(
    &self,
    device: Device,
    p_create_info: *const BufferCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_buffer: *mut Buffer
) -> Result

unsafe fn destroy_buffer(
    &self,
    device: Device,
    buffer: Buffer,
    p_allocator: *const AllocationCallbacks
)

unsafe fn create_buffer_view(
    &self,
    device: Device,
    p_create_info: *const BufferViewCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_view: *mut BufferView
) -> Result

unsafe fn destroy_buffer_view(
    &self,
    device: Device,
    buffer_view: BufferView,
    p_allocator: *const AllocationCallbacks
)

unsafe fn create_image(
    &self,
    device: Device,
    p_create_info: *const ImageCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_image: *mut Image
) -> Result

unsafe fn destroy_image(
    &self,
    device: Device,
    image: Image,
    p_allocator: *const AllocationCallbacks
)

unsafe fn get_image_subresource_layout(
    &self,
    device: Device,
    image: Image,
    p_subresource: *const ImageSubresource,
    p_layout: *mut SubresourceLayout
)

unsafe fn create_image_view(
    &self,
    device: Device,
    p_create_info: *const ImageViewCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_view: *mut ImageView
) -> Result

unsafe fn destroy_image_view(
    &self,
    device: Device,
    image_view: ImageView,
    p_allocator: *const AllocationCallbacks
)

unsafe fn create_shader_module(
    &self,
    device: Device,
    p_create_info: *const ShaderModuleCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_shader_module: *mut ShaderModule
) -> Result

unsafe fn destroy_shader_module(
    &self,
    device: Device,
    shader_module: ShaderModule,
    p_allocator: *const AllocationCallbacks
)

unsafe fn create_pipeline_cache(
    &self,
    device: Device,
    p_create_info: *const PipelineCacheCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_pipeline_cache: *mut PipelineCache
) -> Result

unsafe fn destroy_pipeline_cache(
    &self,
    device: Device,
    pipeline_cache: PipelineCache,
    p_allocator: *const AllocationCallbacks
)

unsafe fn get_pipeline_cache_data(
    &self,
    device: Device,
    pipeline_cache: PipelineCache,
    p_data_size: *mut size_t,
    p_data: *mut c_void
) -> Result

unsafe fn merge_pipeline_caches(
    &self,
    device: Device,
    dst_cache: PipelineCache,
    src_cache_count: uint32_t,
    p_src_caches: *const PipelineCache
) -> Result

unsafe fn create_graphics_pipelines(
    &self,
    device: Device,
    pipeline_cache: PipelineCache,
    create_info_count: uint32_t,
    p_create_infos: *const GraphicsPipelineCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_pipelines: *mut Pipeline
) -> Result

unsafe fn create_compute_pipelines(
    &self,
    device: Device,
    pipeline_cache: PipelineCache,
    create_info_count: uint32_t,
    p_create_infos: *const ComputePipelineCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_pipelines: *mut Pipeline
) -> Result

unsafe fn destroy_pipeline(
    &self,
    device: Device,
    pipeline: Pipeline,
    p_allocator: *const AllocationCallbacks
)

unsafe fn create_pipeline_layout(
    &self,
    device: Device,
    p_create_info: *const PipelineLayoutCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_pipeline_layout: *mut PipelineLayout
) -> Result

unsafe fn destroy_pipeline_layout(
    &self,
    device: Device,
    pipeline_layout: PipelineLayout,
    p_allocator: *const AllocationCallbacks
)

unsafe fn create_sampler(
    &self,
    device: Device,
    p_create_info: *const SamplerCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_sampler: *mut Sampler
) -> Result

unsafe fn destroy_sampler(
    &self,
    device: Device,
    sampler: Sampler,
    p_allocator: *const AllocationCallbacks
)

unsafe fn create_descriptor_set_layout(
    &self,
    device: Device,
    p_create_info: *const DescriptorSetLayoutCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_set_layout: *mut DescriptorSetLayout
) -> Result

unsafe fn destroy_descriptor_set_layout(
    &self,
    device: Device,
    descriptor_set_layout: DescriptorSetLayout,
    p_allocator: *const AllocationCallbacks
)

unsafe fn create_descriptor_pool(
    &self,
    device: Device,
    p_create_info: *const DescriptorPoolCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_descriptor_pool: *mut DescriptorPool
) -> Result

unsafe fn destroy_descriptor_pool(
    &self,
    device: Device,
    descriptor_pool: DescriptorPool,
    p_allocator: *const AllocationCallbacks
)

unsafe fn reset_descriptor_pool(
    &self,
    device: Device,
    descriptor_pool: DescriptorPool,
    flags: DescriptorPoolResetFlags
) -> Result

unsafe fn allocate_descriptor_sets(
    &self,
    device: Device,
    p_allocate_info: *const DescriptorSetAllocateInfo,
    p_descriptor_sets: *mut DescriptorSet
) -> Result

unsafe fn free_descriptor_sets(
    &self,
    device: Device,
    descriptor_pool: DescriptorPool,
    descriptor_set_count: uint32_t,
    p_descriptor_sets: *const DescriptorSet
) -> Result

unsafe fn update_descriptor_sets(
    &self,
    device: Device,
    descriptor_write_count: uint32_t,
    p_descriptor_writes: *const WriteDescriptorSet,
    descriptor_copy_count: uint32_t,
    p_descriptor_copies: *const CopyDescriptorSet
)

unsafe fn create_framebuffer(
    &self,
    device: Device,
    p_create_info: *const FramebufferCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_framebuffer: *mut Framebuffer
) -> Result

unsafe fn destroy_framebuffer(
    &self,
    device: Device,
    framebuffer: Framebuffer,
    p_allocator: *const AllocationCallbacks
)

unsafe fn create_render_pass(
    &self,
    device: Device,
    p_create_info: *const RenderPassCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_render_pass: *mut RenderPass
) -> Result

unsafe fn destroy_render_pass(
    &self,
    device: Device,
    render_pass: RenderPass,
    p_allocator: *const AllocationCallbacks
)

unsafe fn get_render_area_granularity(
    &self,
    device: Device,
    render_pass: RenderPass,
    p_granularity: *mut Extent2D
)

unsafe fn create_command_pool(
    &self,
    device: Device,
    p_create_info: *const CommandPoolCreateInfo,
    p_allocator: *const AllocationCallbacks,
    p_command_pool: *mut CommandPool
) -> Result

unsafe fn destroy_command_pool(
    &self,
    device: Device,
    command_pool: CommandPool,
    p_allocator: *const AllocationCallbacks
)

unsafe fn reset_command_pool(
    &self,
    device: Device,
    command_pool: CommandPool,
    flags: CommandPoolResetFlags
) -> Result

unsafe fn allocate_command_buffers(
    &self,
    device: Device,
    p_allocate_info: *const CommandBufferAllocateInfo,
    p_command_buffers: *mut CommandBuffer
) -> Result

unsafe fn free_command_buffers(
    &self,
    device: Device,
    command_pool: CommandPool,
    command_buffer_count: uint32_t,
    p_command_buffers: *const CommandBuffer
)

unsafe fn begin_command_buffer(
    &self,
    command_buffer: CommandBuffer,
    p_begin_info: *const CommandBufferBeginInfo
) -> Result

unsafe fn end_command_buffer(&self, command_buffer: CommandBuffer) -> Result

unsafe fn reset_command_buffer(
    &self,
    command_buffer: CommandBuffer,
    flags: CommandBufferResetFlags
) -> Result

unsafe fn cmd_bind_pipeline(
    &self,
    command_buffer: CommandBuffer,
    pipeline_bind_point: PipelineBindPoint,
    pipeline: Pipeline
)

unsafe fn cmd_set_viewport(
    &self,
    command_buffer: CommandBuffer,
    first_viewport: uint32_t,
    viewport_count: uint32_t,
    p_viewports: *const Viewport
)

unsafe fn cmd_set_scissor(
    &self,
    command_buffer: CommandBuffer,
    first_scissor: uint32_t,
    scissor_count: uint32_t,
    p_scissors: *const Rect2D
)

unsafe fn cmd_set_line_width(
    &self,
    command_buffer: CommandBuffer,
    line_width: c_float
)

unsafe fn cmd_set_depth_bias(
    &self,
    command_buffer: CommandBuffer,
    depth_bias_constant_factor: c_float,
    depth_bias_clamp: c_float,
    depth_bias_slope_factor: c_float
)

unsafe fn cmd_set_blend_constants(
    &self,
    command_buffer: CommandBuffer,
    blend_constants: *const [c_float; 4]
)

unsafe fn cmd_set_depth_bounds(
    &self,
    command_buffer: CommandBuffer,
    min_depth_bounds: c_float,
    max_depth_bounds: c_float
)

unsafe fn cmd_set_stencil_compare_mask(
    &self,
    command_buffer: CommandBuffer,
    face_mask: StencilFaceFlags,
    compare_mask: uint32_t
)

unsafe fn cmd_set_stencil_write_mask(
    &self,
    command_buffer: CommandBuffer,
    face_mask: StencilFaceFlags,
    write_mask: uint32_t
)

unsafe fn cmd_set_stencil_reference(
    &self,
    command_buffer: CommandBuffer,
    face_mask: StencilFaceFlags,
    reference: uint32_t
)

unsafe fn cmd_bind_descriptor_sets(
    &self,
    command_buffer: CommandBuffer,
    pipeline_bind_point: PipelineBindPoint,
    layout: PipelineLayout,
    first_set: uint32_t,
    descriptor_set_count: uint32_t,
    p_descriptor_sets: *const DescriptorSet,
    dynamic_offset_count: uint32_t,
    p_dynamic_offsets: *const uint32_t
)

unsafe fn cmd_bind_index_buffer(
    &self,
    command_buffer: CommandBuffer,
    buffer: Buffer,
    offset: DeviceSize,
    index_type: IndexType
)

unsafe fn cmd_bind_vertex_buffers(
    &self,
    command_buffer: CommandBuffer,
    first_binding: uint32_t,
    binding_count: uint32_t,
    p_buffers: *const Buffer,
    p_offsets: *const DeviceSize
)

unsafe fn cmd_draw(
    &self,
    command_buffer: CommandBuffer,
    vertex_count: uint32_t,
    instance_count: uint32_t,
    first_vertex: uint32_t,
    first_instance: uint32_t
)

unsafe fn cmd_draw_indexed(
    &self,
    command_buffer: CommandBuffer,
    index_count: uint32_t,
    instance_count: uint32_t,
    first_index: uint32_t,
    vertex_offset: int32_t,
    first_instance: uint32_t
)

unsafe fn cmd_draw_indirect(
    &self,
    command_buffer: CommandBuffer,
    buffer: Buffer,
    offset: DeviceSize,
    draw_count: uint32_t,
    stride: uint32_t
)

unsafe fn cmd_draw_indexed_indirect(
    &self,
    command_buffer: CommandBuffer,
    buffer: Buffer,
    offset: DeviceSize,
    draw_count: uint32_t,
    stride: uint32_t
)

unsafe fn cmd_dispatch(
    &self,
    command_buffer: CommandBuffer,
    x: uint32_t,
    y: uint32_t,
    z: uint32_t
)

unsafe fn cmd_dispatch_indirect(
    &self,
    command_buffer: CommandBuffer,
    buffer: Buffer,
    offset: DeviceSize
)

unsafe fn cmd_copy_buffer(
    &self,
    command_buffer: CommandBuffer,
    src_buffer: Buffer,
    dst_buffer: Buffer,
    region_count: uint32_t,
    p_regions: *const BufferCopy
)

unsafe fn cmd_copy_image(
    &self,
    command_buffer: CommandBuffer,
    src_image: Image,
    src_image_layout: ImageLayout,
    dst_image: Image,
    dst_image_layout: ImageLayout,
    region_count: uint32_t,
    p_regions: *const ImageCopy
)

unsafe fn cmd_blit_image(
    &self,
    command_buffer: CommandBuffer,
    src_image: Image,
    src_image_layout: ImageLayout,
    dst_image: Image,
    dst_image_layout: ImageLayout,
    region_count: uint32_t,
    p_regions: *const ImageBlit,
    filter: Filter
)

unsafe fn cmd_copy_buffer_to_image(
    &self,
    command_buffer: CommandBuffer,
    src_buffer: Buffer,
    dst_image: Image,
    dst_image_layout: ImageLayout,
    region_count: uint32_t,
    p_regions: *const BufferImageCopy
)

unsafe fn cmd_copy_image_to_buffer(
    &self,
    command_buffer: CommandBuffer,
    src_image: Image,
    src_image_layout: ImageLayout,
    dst_buffer: Buffer,
    region_count: uint32_t,
    p_regions: *const BufferImageCopy
)

unsafe fn cmd_update_buffer(
    &self,
    command_buffer: CommandBuffer,
    dst_buffer: Buffer,
    dst_offset: DeviceSize,
    data_size: DeviceSize,
    p_data: *const c_void
)

unsafe fn cmd_fill_buffer(
    &self,
    command_buffer: CommandBuffer,
    dst_buffer: Buffer,
    dst_offset: DeviceSize,
    size: DeviceSize,
    data: uint32_t
)

unsafe fn cmd_clear_color_image(
    &self,
    command_buffer: CommandBuffer,
    image: Image,
    image_layout: ImageLayout,
    p_color: *const ClearColorValue,
    range_count: uint32_t,
    p_ranges: *const ImageSubresourceRange
)

unsafe fn cmd_clear_depth_stencil_image(
    &self,
    command_buffer: CommandBuffer,
    image: Image,
    image_layout: ImageLayout,
    p_depth_stencil: *const ClearDepthStencilValue,
    range_count: uint32_t,
    p_ranges: *const ImageSubresourceRange
)

unsafe fn cmd_clear_attachments(
    &self,
    command_buffer: CommandBuffer,
    attachment_count: uint32_t,
    p_attachments: *const ClearAttachment,
    rect_count: uint32_t,
    p_rects: *const ClearRect
)

unsafe fn cmd_resolve_image(
    &self,
    command_buffer: CommandBuffer,
    src_image: Image,
    src_image_layout: ImageLayout,
    dst_image: Image,
    dst_image_layout: ImageLayout,
    region_count: uint32_t,
    p_regions: *const ImageResolve
)

unsafe fn cmd_set_event(
    &self,
    command_buffer: CommandBuffer,
    event: Event,
    stage_mask: PipelineStageFlags
)

unsafe fn cmd_reset_event(
    &self,
    command_buffer: CommandBuffer,
    event: Event,
    stage_mask: PipelineStageFlags
)

unsafe fn cmd_wait_events(
    &self,
    command_buffer: CommandBuffer,
    event_count: uint32_t,
    p_events: *const Event,
    src_stage_mask: PipelineStageFlags,
    dst_stage_mask: PipelineStageFlags,
    memory_barrier_count: uint32_t,
    p_memory_barriers: *const MemoryBarrier,
    buffer_memory_barrier_count: uint32_t,
    p_buffer_memory_barriers: *const BufferMemoryBarrier,
    image_memory_barrier_count: uint32_t,
    p_image_memory_barriers: *const ImageMemoryBarrier
)

unsafe fn cmd_pipeline_barrier(
    &self,
    command_buffer: CommandBuffer,
    src_stage_mask: PipelineStageFlags,
    dst_stage_mask: PipelineStageFlags,
    dependency_flags: DependencyFlags,
    memory_barrier_count: uint32_t,
    p_memory_barriers: *const MemoryBarrier,
    buffer_memory_barrier_count: uint32_t,
    p_buffer_memory_barriers: *const BufferMemoryBarrier,
    image_memory_barrier_count: uint32_t,
    p_image_memory_barriers: *const ImageMemoryBarrier
)

unsafe fn cmd_begin_query(
    &self,
    command_buffer: CommandBuffer,
    query_pool: QueryPool,
    query: uint32_t,
    flags: QueryControlFlags
)

unsafe fn cmd_end_query(
    &self,
    command_buffer: CommandBuffer,
    query_pool: QueryPool,
    query: uint32_t
)

unsafe fn cmd_reset_query_pool(
    &self,
    command_buffer: CommandBuffer,
    query_pool: QueryPool,
    first_query: uint32_t,
    query_count: uint32_t
)

unsafe fn cmd_write_timestamp(
    &self,
    command_buffer: CommandBuffer,
    pipeline_stage: PipelineStageFlags,
    query_pool: QueryPool,
    query: uint32_t
)

unsafe fn cmd_copy_query_pool_results(
    &self,
    command_buffer: CommandBuffer,
    query_pool: QueryPool,
    first_query: uint32_t,
    query_count: uint32_t,
    dst_buffer: Buffer,
    dst_offset: DeviceSize,
    stride: DeviceSize,
    flags: QueryResultFlags
)

unsafe fn cmd_push_constants(
    &self,
    command_buffer: CommandBuffer,
    layout: PipelineLayout,
    stage_flags: ShaderStageFlags,
    offset: uint32_t,
    size: uint32_t,
    p_values: *const c_void
)

unsafe fn cmd_begin_render_pass(
    &self,
    command_buffer: CommandBuffer,
    p_render_pass_begin: *const RenderPassBeginInfo,
    contents: SubpassContents
)

unsafe fn cmd_next_subpass(
    &self,
    command_buffer: CommandBuffer,
    contents: SubpassContents
)

unsafe fn cmd_end_render_pass(&self, command_buffer: CommandBuffer)

unsafe fn cmd_execute_commands(
    &self,
    command_buffer: CommandBuffer,
    command_buffer_count: uint32_t,
    p_command_buffers: *const CommandBuffer
)

Trait Implementations

impl Clone for DeviceFnV1_0

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Send for DeviceFnV1_0

impl Sync for DeviceFnV1_0