Struct vulkano::swapchain::SwapchainAcquireFuture

pub struct SwapchainAcquireFuture { /* private fields */ }

Represents the moment when the GPU will have access to a swapchain image.

Implementations

impl SwapchainAcquireFuture

pub fn image_index(&self) -> u32

Returns the index of the image in the list of images returned when creating the swapchain.

pub fn swapchain(&self) -> &Arc<Swapchain>

Returns the corresponding swapchain.

pub fn wait(&self, timeout: Option<Duration>) -> Result<(), VulkanError>

Blocks the current thread until the swapchain image has been acquired, or timeout

If timeout is None, will potentially block forever

You still need to join with this future for present to work

Trait Implementations

impl DeviceOwned for SwapchainAcquireFuture

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

Returns the device that owns self.

impl Drop for SwapchainAcquireFuture

fn drop(&mut self)

Executes the destructor for this type.

impl GpuFuture for SwapchainAcquireFuture

fn cleanup_finished(&mut self)

If possible, checks whether the submission has finished. If so, gives up ownership of the resources used by these submissions.

unsafe fn build_submission( &self ) -> Result<SubmitAnyBuilder, Validated<VulkanError>>

Builds a submission that, if submitted, makes sure that the event represented by this GpuFuture will happen, and possibly contains extra elements (eg. a semaphore wait or an event wait) that makes the dependency with subsequent operations work.

fn flush(&self) -> Result<(), Validated<VulkanError>>

Flushes the future and submits to the GPU the actions that will permit this future to occur.

unsafe fn signal_finished(&self)

Sets the future to its “complete” state, meaning that it can safely be destroyed.

fn queue_change_allowed(&self) -> bool

Returns true if elements submitted after this future can be submitted to a different queue than the other returned by queue().

fn queue(&self) -> Option<Arc<Queue>>

Returns the queue that triggers the event. Returns None if unknown or irrelevant.

fn check_buffer_access( &self, _buffer: &Buffer, _range: Range<DeviceSize>, _exclusive: bool, _queue: &Queue ) -> Result<(), AccessCheckError>

Checks whether submitting something after this future grants access (exclusive or shared, depending on the parameter) to the given buffer on the given queue.

fn check_image_access( &self, image: &Image, _range: Range<DeviceSize>, _exclusive: bool, expected_layout: ImageLayout, _queue: &Queue ) -> Result<(), AccessCheckError>

Checks whether submitting something after this future grants access (exclusive or shared, depending on the parameter) to the given image on the given queue.

fn check_swapchain_image_acquired( &self, swapchain: &Swapchain, image_index: u32, before: bool ) -> Result<(), AccessCheckError>

Checks whether accessing a swapchain image is permitted.

fn join<F>(self, other: F) -> JoinFuture<Self, F>where Self: Sized, F: GpuFuture,

Joins this future with another one, representing the moment when both events have happened.

fn then_execute( self, queue: Arc<Queue>, command_buffer: Arc<impl PrimaryCommandBufferAbstract + 'static> ) -> Result<CommandBufferExecFuture<Self>, CommandBufferExecError>where Self: Sized,

Executes a command buffer after this future.

fn then_execute_same_queue( self, command_buffer: Arc<impl PrimaryCommandBufferAbstract + 'static> ) -> Result<CommandBufferExecFuture<Self>, CommandBufferExecError>where Self: Sized,

Executes a command buffer after this future, on the same queue as the future.

fn then_signal_semaphore(self) -> SemaphoreSignalFuture<Self>where Self: Sized,

Signals a semaphore after this future. Returns another future that represents the signal.

fn then_signal_semaphore_and_flush( self ) -> Result<SemaphoreSignalFuture<Self>, Validated<VulkanError>>where Self: Sized,

Signals a semaphore after this future and flushes it. Returns another future that represents the moment when the semaphore is signalled.

fn then_signal_fence(self) -> FenceSignalFuture<Self> where Self: Sized,

Signals a fence after this future. Returns another future that represents the signal.

fn then_signal_fence_and_flush( self ) -> Result<FenceSignalFuture<Self>, Validated<VulkanError>>where Self: Sized,

Signals a fence after this future. Returns another future that represents the signal.

fn then_swapchain_present( self, queue: Arc<Queue>, swapchain_info: SwapchainPresentInfo ) -> PresentFuture<Self>where Self: Sized,

Presents a swapchain image after this future.

fn boxed(self) -> Box<dyn GpuFuture>where Self: Sized + 'static,

Turn the current future into a Box<dyn GpuFuture>.

fn boxed_send(self) -> Box<dyn GpuFuture + Send>where Self: Sized + Send + 'static,

Turn the current future into a Box<dyn GpuFuture + Send>.

fn boxed_sync(self) -> Box<dyn GpuFuture + Sync>where Self: Sized + Sync + 'static,

Turn the current future into a Box<dyn GpuFuture + Sync>.

fn boxed_send_sync(self) -> Box<dyn GpuFuture + Send + Sync>where Self: Sized + Send + Sync + 'static,

Turn the current future into a Box<dyn GpuFuture + Send + Sync>.