use std::hash::Hash;
use std::hash::Hasher;
use std::iter::Empty;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use crate::buffer::BufferAccess;
use crate::device::Device;
use crate::format::ClearValue;
use crate::format::Format;
use crate::format::FormatDesc;
use crate::format::FormatTy;
use crate::image::sys::ImageCreationError;
use crate::image::sys::UnsafeImage;
use crate::image::traits::ImageAccess;
use crate::image::traits::ImageClearValue;
use crate::image::traits::ImageContent;
use crate::image::ImageCreateFlags;
use crate::image::ImageDescriptorLayouts;
use crate::image::ImageDimensions;
use crate::image::ImageInner;
use crate::image::ImageLayout;
use crate::image::ImageUsage;
use crate::memory::pool::AllocFromRequirementsFilter;
use crate::memory::pool::AllocLayout;
use crate::memory::pool::MappingRequirement;
use crate::memory::pool::MemoryPool;
use crate::memory::pool::MemoryPoolAlloc;
use crate::memory::pool::PotentialDedicatedAllocation;
use crate::memory::pool::StdMemoryPoolAlloc;
use crate::memory::DedicatedAlloc;
use crate::sync::AccessError;
use crate::sync::Sharing;
#[derive(Debug)]
pub struct AttachmentImage<F = Format, A = PotentialDedicatedAllocation<StdMemoryPoolAlloc>> {
image: UnsafeImage,
memory: A,
format: F,
attachment_layout: ImageLayout,
initialized: AtomicBool,
gpu_lock: AtomicUsize,
}
impl<F> AttachmentImage<F> {
#[inline]
pub fn new(
device: Arc<Device>,
dimensions: [u32; 2],
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
AttachmentImage::new_impl(device, dimensions, format, ImageUsage::none(), 1)
}
#[inline]
pub fn input_attachment(
device: Arc<Device>,
dimensions: [u32; 2],
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let base_usage = ImageUsage {
input_attachment: true,
..ImageUsage::none()
};
AttachmentImage::new_impl(device, dimensions, format, base_usage, 1)
}
#[inline]
pub fn multisampled(
device: Arc<Device>,
dimensions: [u32; 2],
samples: u32,
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
AttachmentImage::new_impl(device, dimensions, format, ImageUsage::none(), samples)
}
#[inline]
pub fn multisampled_input_attachment(
device: Arc<Device>,
dimensions: [u32; 2],
samples: u32,
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let base_usage = ImageUsage {
input_attachment: true,
..ImageUsage::none()
};
AttachmentImage::new_impl(device, dimensions, format, base_usage, samples)
}
#[inline]
pub fn with_usage(
device: Arc<Device>,
dimensions: [u32; 2],
format: F,
usage: ImageUsage,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
AttachmentImage::new_impl(device, dimensions, format, usage, 1)
}
#[inline]
pub fn multisampled_with_usage(
device: Arc<Device>,
dimensions: [u32; 2],
samples: u32,
format: F,
usage: ImageUsage,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
AttachmentImage::new_impl(device, dimensions, format, usage, samples)
}
#[inline]
pub fn sampled(
device: Arc<Device>,
dimensions: [u32; 2],
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let base_usage = ImageUsage {
sampled: true,
..ImageUsage::none()
};
AttachmentImage::new_impl(device, dimensions, format, base_usage, 1)
}
#[inline]
pub fn sampled_input_attachment(
device: Arc<Device>,
dimensions: [u32; 2],
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let base_usage = ImageUsage {
sampled: true,
input_attachment: true,
..ImageUsage::none()
};
AttachmentImage::new_impl(device, dimensions, format, base_usage, 1)
}
#[inline]
pub fn sampled_multisampled(
device: Arc<Device>,
dimensions: [u32; 2],
samples: u32,
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let base_usage = ImageUsage {
sampled: true,
..ImageUsage::none()
};
AttachmentImage::new_impl(device, dimensions, format, base_usage, samples)
}
#[inline]
pub fn sampled_multisampled_input_attachment(
device: Arc<Device>,
dimensions: [u32; 2],
samples: u32,
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let base_usage = ImageUsage {
sampled: true,
input_attachment: true,
..ImageUsage::none()
};
AttachmentImage::new_impl(device, dimensions, format, base_usage, samples)
}
#[inline]
pub fn transient(
device: Arc<Device>,
dimensions: [u32; 2],
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let base_usage = ImageUsage {
transient_attachment: true,
..ImageUsage::none()
};
AttachmentImage::new_impl(device, dimensions, format, base_usage, 1)
}
#[inline]
pub fn transient_input_attachment(
device: Arc<Device>,
dimensions: [u32; 2],
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let base_usage = ImageUsage {
transient_attachment: true,
input_attachment: true,
..ImageUsage::none()
};
AttachmentImage::new_impl(device, dimensions, format, base_usage, 1)
}
#[inline]
pub fn transient_multisampled(
device: Arc<Device>,
dimensions: [u32; 2],
samples: u32,
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let base_usage = ImageUsage {
transient_attachment: true,
..ImageUsage::none()
};
AttachmentImage::new_impl(device, dimensions, format, base_usage, samples)
}
#[inline]
pub fn transient_multisampled_input_attachment(
device: Arc<Device>,
dimensions: [u32; 2],
samples: u32,
format: F,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let base_usage = ImageUsage {
transient_attachment: true,
input_attachment: true,
..ImageUsage::none()
};
AttachmentImage::new_impl(device, dimensions, format, base_usage, samples)
}
fn new_impl(
device: Arc<Device>,
dimensions: [u32; 2],
format: F,
base_usage: ImageUsage,
samples: u32,
) -> Result<Arc<AttachmentImage<F>>, ImageCreationError>
where
F: FormatDesc,
{
let is_depth = match format.format().ty() {
FormatTy::Depth => true,
FormatTy::DepthStencil => true,
FormatTy::Stencil => true,
FormatTy::Compressed => panic!(),
_ => false,
};
let usage = ImageUsage {
color_attachment: !is_depth,
depth_stencil_attachment: is_depth,
..base_usage
};
let (image, mem_reqs) = unsafe {
let dims = ImageDimensions::Dim2d {
width: dimensions[0],
height: dimensions[1],
array_layers: 1,
};
UnsafeImage::new(
device.clone(),
usage,
format.format(),
ImageCreateFlags::none(),
dims,
samples,
1,
Sharing::Exclusive::<Empty<u32>>,
false,
false,
)?
};
let memory = MemoryPool::alloc_from_requirements(
&Device::standard_pool(&device),
&mem_reqs,
AllocLayout::Optimal,
MappingRequirement::DoNotMap,
DedicatedAlloc::Image(&image),
|t| {
if t.is_device_local() {
AllocFromRequirementsFilter::Preferred
} else {
AllocFromRequirementsFilter::Allowed
}
},
)?;
debug_assert!((memory.offset() % mem_reqs.alignment) == 0);
unsafe {
image.bind_memory(memory.memory(), memory.offset())?;
}
Ok(Arc::new(AttachmentImage {
image,
memory,
format,
attachment_layout: if is_depth {
ImageLayout::DepthStencilAttachmentOptimal
} else {
ImageLayout::ColorAttachmentOptimal
},
initialized: AtomicBool::new(false),
gpu_lock: AtomicUsize::new(0),
}))
}
}
impl<F, A> AttachmentImage<F, A> {
#[inline]
pub fn dimensions(&self) -> [u32; 2] {
let dims = self.image.dimensions();
[dims.width(), dims.height()]
}
}
unsafe impl<F, A> ImageAccess for AttachmentImage<F, A>
where
F: 'static + Send + Sync,
{
#[inline]
fn inner(&self) -> ImageInner {
ImageInner {
image: &self.image,
first_layer: 0,
num_layers: self.image.dimensions().array_layers() as usize,
first_mipmap_level: 0,
num_mipmap_levels: 1,
}
}
#[inline]
fn initial_layout_requirement(&self) -> ImageLayout {
self.attachment_layout
}
#[inline]
fn final_layout_requirement(&self) -> ImageLayout {
self.attachment_layout
}
#[inline]
fn descriptor_layouts(&self) -> Option<ImageDescriptorLayouts> {
Some(ImageDescriptorLayouts {
storage_image: ImageLayout::ShaderReadOnlyOptimal,
combined_image_sampler: ImageLayout::ShaderReadOnlyOptimal,
sampled_image: ImageLayout::ShaderReadOnlyOptimal,
input_attachment: ImageLayout::ShaderReadOnlyOptimal,
})
}
#[inline]
fn conflicts_buffer(&self, other: &dyn BufferAccess) -> bool {
false
}
#[inline]
fn conflicts_image(&self, other: &dyn ImageAccess) -> bool {
self.conflict_key() == other.conflict_key()
}
#[inline]
fn conflict_key(&self) -> u64 {
self.image.key()
}
#[inline]
fn try_gpu_lock(&self, _: bool, expected_layout: ImageLayout) -> Result<(), AccessError> {
if expected_layout != self.attachment_layout && expected_layout != ImageLayout::Undefined {
if self.initialized.load(Ordering::SeqCst) {
return Err(AccessError::UnexpectedImageLayout {
requested: expected_layout,
allowed: self.attachment_layout,
});
} else {
return Err(AccessError::UnexpectedImageLayout {
requested: expected_layout,
allowed: ImageLayout::Undefined,
});
}
}
if expected_layout != ImageLayout::Undefined {
if !self.initialized.load(Ordering::SeqCst) {
return Err(AccessError::ImageNotInitialized {
requested: expected_layout,
});
}
}
if self
.gpu_lock
.compare_exchange(0, 1, Ordering::SeqCst, Ordering::SeqCst)
.unwrap_or_else(|e| e)
== 0
{
Ok(())
} else {
Err(AccessError::AlreadyInUse)
}
}
#[inline]
unsafe fn increase_gpu_lock(&self) {
let val = self.gpu_lock.fetch_add(1, Ordering::SeqCst);
debug_assert!(val >= 1);
}
#[inline]
unsafe fn unlock(&self, new_layout: Option<ImageLayout>) {
if let Some(new_layout) = new_layout {
debug_assert_eq!(new_layout, self.attachment_layout);
self.initialized.store(true, Ordering::SeqCst);
}
let prev_val = self.gpu_lock.fetch_sub(1, Ordering::SeqCst);
debug_assert!(prev_val >= 1);
}
#[inline]
unsafe fn layout_initialized(&self) {
self.initialized.store(true, Ordering::SeqCst);
}
#[inline]
fn is_layout_initialized(&self) -> bool {
self.initialized.load(Ordering::SeqCst)
}
#[inline]
fn current_miplevels_access(&self) -> std::ops::Range<u32> {
0..self.mipmap_levels()
}
#[inline]
fn current_layer_levels_access(&self) -> std::ops::Range<u32> {
0..1
}
}
unsafe impl<F, A> ImageClearValue<F::ClearValue> for Arc<AttachmentImage<F, A>>
where
F: FormatDesc + 'static + Send + Sync,
{
#[inline]
fn decode(&self, value: F::ClearValue) -> Option<ClearValue> {
Some(self.format.decode_clear_value(value))
}
}
unsafe impl<P, F, A> ImageContent<P> for Arc<AttachmentImage<F, A>>
where
F: 'static + Send + Sync,
{
#[inline]
fn matches_format(&self) -> bool {
true
}
}
impl<F, A> PartialEq for AttachmentImage<F, A>
where
F: 'static + Send + Sync,
{
#[inline]
fn eq(&self, other: &Self) -> bool {
ImageAccess::inner(self) == ImageAccess::inner(other)
}
}
impl<F, A> Eq for AttachmentImage<F, A> where F: 'static + Send + Sync {}
impl<F, A> Hash for AttachmentImage<F, A>
where
F: 'static + Send + Sync,
{
#[inline]
fn hash<H: Hasher>(&self, state: &mut H) {
ImageAccess::inner(self).hash(state);
}
}
#[cfg(test)]
mod tests {
use super::AttachmentImage;
use crate::format::Format;
#[test]
fn create_regular() {
let (device, _) = gfx_dev_and_queue!();
let _img = AttachmentImage::new(device, [32, 32], Format::R8G8B8A8Unorm).unwrap();
}
#[test]
fn create_transient() {
let (device, _) = gfx_dev_and_queue!();
let _img = AttachmentImage::transient(device, [32, 32], Format::R8G8B8A8Unorm).unwrap();
}
#[test]
fn d16_unorm_always_supported() {
let (device, _) = gfx_dev_and_queue!();
let _img = AttachmentImage::new(device, [32, 32], Format::D16Unorm).unwrap();
}
}