Struct vulkano::swapchain::PresentFuture

#[must_use =
  "Dropping this object will immediately block the thread until the GPU has finished processing the submission"]pub struct PresentFuture<P, W> where
    P: GpuFuture,  { /* fields omitted */ }

Represents a swapchain image being presented on the screen.

Implementations

impl<P, W> PresentFuture<P, W> where
    P: GpuFuture, 

pub fn image_id(&self) -> usize

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

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

Returns the corresponding swapchain.

Trait Implementations

impl<P, W> DeviceOwned for PresentFuture<P, W> where
    P: GpuFuture, 

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

Returns the device that owns Self.

impl<P, W> Drop for PresentFuture<P, W> where
    P: GpuFuture, 

fn drop(&mut self)

Executes the destructor for this type.

impl<P, W> GpuFuture for PresentFuture<P, W> where
    P: GpuFuture, 

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<'_>, FlushError>

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<(), FlushError>

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: &dyn BufferAccess,
    exclusive: bool,
    queue: &Queue
) -> Result<Option<(PipelineStages, AccessFlagBits)>, 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: &dyn ImageAccess,
    layout: ImageLayout,
    exclusive: bool,
    queue: &Queue
) -> Result<Option<(PipelineStages, AccessFlagBits)>, 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 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<Cb>(
    self,
    queue: Arc<Queue>,
    command_buffer: Cb
) -> Result<CommandBufferExecFuture<Self, Cb>, CommandBufferExecError> where
    Self: Sized,
    Cb: CommandBuffer + 'static, 

Executes a command buffer after this future.

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

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

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

fn then_swapchain_present<W>(
    self,
    queue: Arc<Queue>,
    swapchain: Arc<Swapchain<W>>,
    image_index: usize
) -> PresentFuture<Self, W> where
    Self: Sized, 

Presents a swapchain image after this future.

fn then_swapchain_present_incremental<W>(
    self,
    queue: Arc<Queue>,
    swapchain: Arc<Swapchain<W>>,
    image_index: usize,
    present_region: PresentRegion
) -> PresentFuture<Self, W> where
    Self: Sized, 

Same as then_swapchain_present, except it allows specifying a present region.