use crate::buffer::BufferAccess;
use crate::command_buffer::submit::SubmitAnyBuilder;
use crate::command_buffer::submit::SubmitCommandBufferBuilder;
use crate::command_buffer::sys::UnsafeCommandBuffer;
use crate::command_buffer::CommandBufferInheritance;
use crate::device::Device;
use crate::device::DeviceOwned;
use crate::device::Queue;
use crate::image::ImageAccess;
use crate::image::ImageLayout;
use crate::render_pass::FramebufferAbstract;
use crate::sync::now;
use crate::sync::AccessCheckError;
use crate::sync::AccessError;
use crate::sync::AccessFlags;
use crate::sync::FlushError;
use crate::sync::GpuFuture;
use crate::sync::NowFuture;
use crate::sync::PipelineMemoryAccess;
use crate::sync::PipelineStages;
use crate::SafeDeref;
use crate::VulkanObject;
use std::borrow::Cow;
use std::error;
use std::fmt;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::sync::Mutex;
pub unsafe trait PrimaryCommandBuffer: DeviceOwned {
fn inner(&self) -> &UnsafeCommandBuffer;
fn lock_submit(
&self,
future: &dyn GpuFuture,
queue: &Queue,
) -> Result<(), CommandBufferExecError>;
unsafe fn unlock(&self);
#[inline]
fn execute(
self,
queue: Arc<Queue>,
) -> Result<CommandBufferExecFuture<NowFuture, Self>, CommandBufferExecError>
where
Self: Sized + 'static,
{
let device = queue.device().clone();
self.execute_after(now(device), queue)
}
#[inline]
fn execute_after<F>(
self,
future: F,
queue: Arc<Queue>,
) -> Result<CommandBufferExecFuture<F, Self>, CommandBufferExecError>
where
Self: Sized + 'static,
F: GpuFuture,
{
assert_eq!(
self.device().internal_object(),
future.device().internal_object()
);
if !future.queue_change_allowed() {
assert!(future.queue().unwrap().is_same(&queue));
}
self.lock_submit(&future, &queue)?;
Ok(CommandBufferExecFuture {
previous: future,
command_buffer: self,
queue,
submitted: Mutex::new(false),
finished: AtomicBool::new(false),
})
}
fn check_buffer_access(
&self,
buffer: &dyn BufferAccess,
exclusive: bool,
queue: &Queue,
) -> Result<Option<(PipelineStages, AccessFlags)>, AccessCheckError>;
fn check_image_access(
&self,
image: &dyn ImageAccess,
layout: ImageLayout,
exclusive: bool,
queue: &Queue,
) -> Result<Option<(PipelineStages, AccessFlags)>, AccessCheckError>;
}
unsafe impl<T> PrimaryCommandBuffer for T
where
T: SafeDeref,
T::Target: PrimaryCommandBuffer,
{
#[inline]
fn inner(&self) -> &UnsafeCommandBuffer {
(**self).inner()
}
#[inline]
fn lock_submit(
&self,
future: &dyn GpuFuture,
queue: &Queue,
) -> Result<(), CommandBufferExecError> {
(**self).lock_submit(future, queue)
}
#[inline]
unsafe fn unlock(&self) {
(**self).unlock();
}
#[inline]
fn check_buffer_access(
&self,
buffer: &dyn BufferAccess,
exclusive: bool,
queue: &Queue,
) -> Result<Option<(PipelineStages, AccessFlags)>, AccessCheckError> {
(**self).check_buffer_access(buffer, exclusive, queue)
}
#[inline]
fn check_image_access(
&self,
image: &dyn ImageAccess,
layout: ImageLayout,
exclusive: bool,
queue: &Queue,
) -> Result<Option<(PipelineStages, AccessFlags)>, AccessCheckError> {
(**self).check_image_access(image, layout, exclusive, queue)
}
}
pub unsafe trait SecondaryCommandBuffer: DeviceOwned {
fn inner(&self) -> &UnsafeCommandBuffer;
fn lock_record(&self) -> Result<(), CommandBufferExecError>;
unsafe fn unlock(&self);
fn inheritance(&self) -> CommandBufferInheritance<&dyn FramebufferAbstract>;
fn num_buffers(&self) -> usize;
fn buffer(&self, index: usize) -> Option<(&dyn BufferAccess, PipelineMemoryAccess)>;
fn num_images(&self) -> usize;
fn image(
&self,
index: usize,
) -> Option<(
&dyn ImageAccess,
PipelineMemoryAccess,
ImageLayout,
ImageLayout,
)>;
}
unsafe impl<T> SecondaryCommandBuffer for T
where
T: SafeDeref,
T::Target: SecondaryCommandBuffer,
{
#[inline]
fn inner(&self) -> &UnsafeCommandBuffer {
(**self).inner()
}
#[inline]
fn lock_record(&self) -> Result<(), CommandBufferExecError> {
(**self).lock_record()
}
#[inline]
unsafe fn unlock(&self) {
(**self).unlock();
}
#[inline]
fn inheritance(&self) -> CommandBufferInheritance<&dyn FramebufferAbstract> {
(**self).inheritance()
}
#[inline]
fn num_buffers(&self) -> usize {
(**self).num_buffers()
}
#[inline]
fn buffer(&self, index: usize) -> Option<(&dyn BufferAccess, PipelineMemoryAccess)> {
(**self).buffer(index)
}
#[inline]
fn num_images(&self) -> usize {
(**self).num_images()
}
#[inline]
fn image(
&self,
index: usize,
) -> Option<(
&dyn ImageAccess,
PipelineMemoryAccess,
ImageLayout,
ImageLayout,
)> {
(**self).image(index)
}
}
#[must_use = "Dropping this object will immediately block the thread until the GPU has finished processing the submission"]
pub struct CommandBufferExecFuture<F, Cb>
where
F: GpuFuture,
Cb: PrimaryCommandBuffer,
{
previous: F,
command_buffer: Cb,
queue: Arc<Queue>,
submitted: Mutex<bool>,
finished: AtomicBool,
}
unsafe impl<F, Cb> GpuFuture for CommandBufferExecFuture<F, Cb>
where
F: GpuFuture,
Cb: PrimaryCommandBuffer,
{
#[inline]
fn cleanup_finished(&mut self) {
self.previous.cleanup_finished();
}
unsafe fn build_submission(&self) -> Result<SubmitAnyBuilder, FlushError> {
Ok(match self.previous.build_submission()? {
SubmitAnyBuilder::Empty => {
let mut builder = SubmitCommandBufferBuilder::new();
builder.add_command_buffer(self.command_buffer.inner());
SubmitAnyBuilder::CommandBuffer(builder)
}
SubmitAnyBuilder::SemaphoresWait(sem) => {
let mut builder: SubmitCommandBufferBuilder = sem.into();
builder.add_command_buffer(self.command_buffer.inner());
SubmitAnyBuilder::CommandBuffer(builder)
}
SubmitAnyBuilder::CommandBuffer(mut builder) => {
builder.add_command_buffer(self.command_buffer.inner());
SubmitAnyBuilder::CommandBuffer(builder)
}
SubmitAnyBuilder::QueuePresent(_) | SubmitAnyBuilder::BindSparse(_) => {
unimplemented!()
}
})
}
#[inline]
fn flush(&self) -> Result<(), FlushError> {
unsafe {
let mut submitted = self.submitted.lock().unwrap();
if *submitted {
return Ok(());
}
let queue = self.queue.clone();
match self.build_submission()? {
SubmitAnyBuilder::Empty => {}
SubmitAnyBuilder::CommandBuffer(builder) => {
builder.submit(&queue)?;
}
_ => unreachable!(),
};
*submitted = true;
Ok(())
}
}
#[inline]
unsafe fn signal_finished(&self) {
if self.finished.swap(true, Ordering::SeqCst) == false {
self.command_buffer.unlock();
}
self.previous.signal_finished();
}
#[inline]
fn queue_change_allowed(&self) -> bool {
false
}
#[inline]
fn queue(&self) -> Option<Arc<Queue>> {
Some(self.queue.clone())
}
#[inline]
fn check_buffer_access(
&self,
buffer: &dyn BufferAccess,
exclusive: bool,
queue: &Queue,
) -> Result<Option<(PipelineStages, AccessFlags)>, AccessCheckError> {
match self
.command_buffer
.check_buffer_access(buffer, exclusive, queue)
{
Ok(v) => Ok(v),
Err(AccessCheckError::Denied(err)) => Err(AccessCheckError::Denied(err)),
Err(AccessCheckError::Unknown) => {
self.previous.check_buffer_access(buffer, exclusive, queue)
}
}
}
#[inline]
fn check_image_access(
&self,
image: &dyn ImageAccess,
layout: ImageLayout,
exclusive: bool,
queue: &Queue,
) -> Result<Option<(PipelineStages, AccessFlags)>, AccessCheckError> {
match self
.command_buffer
.check_image_access(image, layout, exclusive, queue)
{
Ok(v) => Ok(v),
Err(AccessCheckError::Denied(err)) => Err(AccessCheckError::Denied(err)),
Err(AccessCheckError::Unknown) => self
.previous
.check_image_access(image, layout, exclusive, queue),
}
}
}
unsafe impl<F, Cb> DeviceOwned for CommandBufferExecFuture<F, Cb>
where
F: GpuFuture,
Cb: PrimaryCommandBuffer,
{
#[inline]
fn device(&self) -> &Arc<Device> {
self.command_buffer.device()
}
}
impl<F, Cb> Drop for CommandBufferExecFuture<F, Cb>
where
F: GpuFuture,
Cb: PrimaryCommandBuffer,
{
fn drop(&mut self) {
unsafe {
if !*self.finished.get_mut() {
self.flush().unwrap();
self.queue.wait().unwrap();
self.command_buffer.unlock();
self.previous.signal_finished();
}
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CommandBufferExecError {
AccessError {
error: AccessError,
command_name: Cow<'static, str>,
command_param: Cow<'static, str>,
command_offset: usize,
},
OneTimeSubmitAlreadySubmitted,
ExclusiveAlreadyInUse,
}
impl error::Error for CommandBufferExecError {
#[inline]
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
match *self {
CommandBufferExecError::AccessError { ref error, .. } => Some(error),
_ => None,
}
}
}
impl fmt::Display for CommandBufferExecError {
#[inline]
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
write!(
fmt,
"{}",
match *self {
CommandBufferExecError::AccessError { .. } =>
"access to a resource has been denied",
CommandBufferExecError::OneTimeSubmitAlreadySubmitted => {
"the command buffer or one of the secondary command buffers it executes was \
created with the \"one time submit\" flag, but has already been submitted in \
the past"
}
CommandBufferExecError::ExclusiveAlreadyInUse => {
"the command buffer or one of the secondary command buffers it executes is \
already in use was not created with the \"concurrent\" flag"
}
}
)
}
}