Struct vulkano::command_buffer::CommandBufferExecFuture

pub struct CommandBufferExecFuture<F, Cb>where
    F: GpuFuture,
    Cb: CommandBuffer,{ /* private fields */ }

Represents a command buffer being executed by the GPU and the moment when the execution finishes.

Trait Implementations

impl<F, Cb> DeviceOwned for CommandBufferExecFuture<F, Cb>where
    F: GpuFuture,
    Cb: CommandBuffer,

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

Returns the device that owns Self.

impl<F, Cb> Drop for CommandBufferExecFuture<F, Cb>where
    F: GpuFuture,
    Cb: CommandBuffer,

fn drop(&mut self)

Executes the destructor for this type.

impl<F, Cb> GpuFuture for CommandBufferExecFuture<F, Cb>where
    F: GpuFuture,
    Cb: CommandBuffer,

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.