From b86e97f67a07368877bd18501aebcbe80cf93118 Mon Sep 17 00:00:00 2001 From: tcmal Date: Sun, 25 Aug 2024 17:44:24 +0100 Subject: feat(skeleton): add memory pools added stock memory pools behind a feature gate refactored buffers to use them and to have better APIs. moved some util code out of builders::pipeline updated stockton-render for the changes deactivation is a WIP breaks UI drawing, fix WIP --- stockton-skeleton/Cargo.toml | 8 +- stockton-skeleton/src/buffers/dedicated_image.rs | 134 --------- stockton-skeleton/src/buffers/draw.rs | 54 ++++ stockton-skeleton/src/buffers/draw_buffers.rs | 43 --- stockton-skeleton/src/buffers/image.rs | 342 +++++++++++++++++++++ stockton-skeleton/src/buffers/mod.rs | 67 +---- stockton-skeleton/src/buffers/staged.rs | 177 +++++++---- stockton-skeleton/src/buffers/staging.rs | 103 +++++++ stockton-skeleton/src/builders/pipeline.rs | 20 +- stockton-skeleton/src/context.rs | 54 +++- stockton-skeleton/src/error.rs | 12 + stockton-skeleton/src/lib.rs | 1 + stockton-skeleton/src/mem.rs | 368 +++++++++++++++++++++++ stockton-skeleton/src/texture/block.rs | 45 +-- stockton-skeleton/src/texture/load.rs | 223 ++++++-------- stockton-skeleton/src/texture/loader.rs | 259 +++++++--------- stockton-skeleton/src/texture/mod.rs | 1 - stockton-skeleton/src/texture/repo.rs | 80 +++-- stockton-skeleton/src/texture/staging_buffer.rs | 59 ---- stockton-skeleton/src/utils.rs | 6 +- 20 files changed, 1334 insertions(+), 722 deletions(-) delete mode 100644 stockton-skeleton/src/buffers/dedicated_image.rs create mode 100644 stockton-skeleton/src/buffers/draw.rs delete mode 100644 stockton-skeleton/src/buffers/draw_buffers.rs create mode 100644 stockton-skeleton/src/buffers/image.rs create mode 100644 stockton-skeleton/src/buffers/staging.rs create mode 100644 stockton-skeleton/src/mem.rs delete mode 100644 stockton-skeleton/src/texture/staging_buffer.rs (limited to 'stockton-skeleton') diff --git a/stockton-skeleton/Cargo.toml b/stockton-skeleton/Cargo.toml index 8e3df4b..d7f4a99 100644 --- a/stockton-skeleton/Cargo.toml +++ b/stockton-skeleton/Cargo.toml @@ -16,16 +16,20 @@ shaderc = "^0.7" log = "0.4.0" image = "0.23.11" legion = { version = "^0.3" } -rendy-memory = { path = "../rendy-memory" } rendy-descriptor = { path = "../rendy-descriptor" } anyhow = "1.0.40" thiserror = "1.0.25" derive_builder = "0.10.2" [features] -default = ["vulkan"] +default = ["vulkan", "rendy-pools"] vulkan = ["gfx-backend-vulkan"] +rendy-pools = ["rendy-memory"] [dependencies.gfx-backend-vulkan] version = "^0.8.0" optional = true + +[dependencies.rendy-memory] +path = "../rendy-memory" +optional = true diff --git a/stockton-skeleton/src/buffers/dedicated_image.rs b/stockton-skeleton/src/buffers/dedicated_image.rs deleted file mode 100644 index bf49a38..0000000 --- a/stockton-skeleton/src/buffers/dedicated_image.rs +++ /dev/null @@ -1,134 +0,0 @@ -//! A dedicated image. Used for depth buffers. - -use crate::texture::PIXEL_SIZE; -use crate::types::*; - -use std::mem::ManuallyDrop; - -use anyhow::{Context, Result}; -use hal::{ - format::{Format, Swizzle}, - image::{SubresourceRange, Usage, Usage as ImgUsage, ViewKind}, - memory, - memory::Properties, - MemoryTypeId, -}; -use thiserror::Error; - -/// Holds an image that's loaded into GPU memory dedicated only to that image, bypassing the memory allocator. -pub struct DedicatedLoadedImage { - /// The GPU Image handle - image: ManuallyDrop, - - /// The full view of the image - pub image_view: ManuallyDrop, - - /// The memory backing the image - memory: ManuallyDrop, -} - -#[derive(Debug, Error)] -pub enum ImageLoadError { - #[error("No suitable memory type for image memory")] - NoMemoryTypes, -} - -impl DedicatedLoadedImage { - pub fn new( - device: &mut DeviceT, - adapter: &Adapter, - format: Format, - usage: Usage, - resources: SubresourceRange, - width: usize, - height: usize, - ) -> Result { - let (memory, image_ref) = { - // Round up the size to align properly - let initial_row_size = PIXEL_SIZE * width; - let limits = adapter.physical_device.properties().limits; - let row_alignment_mask = limits.optimal_buffer_copy_pitch_alignment as u32 - 1; - - let row_size = - ((initial_row_size as u32 + row_alignment_mask) & !row_alignment_mask) as usize; - debug_assert!(row_size as usize >= initial_row_size); - - // Make the image - let mut image_ref = unsafe { - use hal::image::{Kind, Tiling, ViewCapabilities}; - - device.create_image( - Kind::D2(width as u32, height as u32, 1, 1), - 1, - format, - Tiling::Optimal, - usage, - memory::SparseFlags::empty(), - ViewCapabilities::empty(), - ) - } - .context("Error creating image")?; - - // Allocate memory - let memory = unsafe { - let requirements = device.get_image_requirements(&image_ref); - - let memory_type_id = adapter - .physical_device - .memory_properties() - .memory_types - .iter() - .enumerate() - .find(|&(id, memory_type)| { - requirements.type_mask & (1 << id) != 0 - && memory_type.properties.contains(Properties::DEVICE_LOCAL) - }) - .map(|(id, _)| MemoryTypeId(id)) - .ok_or(ImageLoadError::NoMemoryTypes)?; - - let memory = device - .allocate_memory(memory_type_id, requirements.size) - .context("Error allocating memory for image")?; - - device - .bind_image_memory(&memory, 0, &mut image_ref) - .context("Error binding memory to image")?; - - memory - }; - - (memory, image_ref) - }; - - // Create ImageView and sampler - let image_view = unsafe { - device.create_image_view( - &image_ref, - ViewKind::D2, - format, - Swizzle::NO, - ImgUsage::DEPTH_STENCIL_ATTACHMENT, - resources, - ) - } - .context("Error creating image view")?; - - Ok(DedicatedLoadedImage { - image: ManuallyDrop::new(image_ref), - image_view: ManuallyDrop::new(image_view), - memory: ManuallyDrop::new(memory), - }) - } - - /// Properly frees/destroys all the objects in this struct - /// Dropping without doing this is a bad idea - pub fn deactivate(self, device: &mut DeviceT) { - unsafe { - use core::ptr::read; - - device.destroy_image_view(ManuallyDrop::into_inner(read(&self.image_view))); - device.destroy_image(ManuallyDrop::into_inner(read(&self.image))); - device.free_memory(ManuallyDrop::into_inner(read(&self.memory))); - } - } -} diff --git a/stockton-skeleton/src/buffers/draw.rs b/stockton-skeleton/src/buffers/draw.rs new file mode 100644 index 0000000..cd571e3 --- /dev/null +++ b/stockton-skeleton/src/buffers/draw.rs @@ -0,0 +1,54 @@ +//! A vertex and index buffer set for drawing + +use super::staged::StagedBuffer; +use crate::{ + context::RenderingContext, + mem::{MappableBlock, MemoryPool}, +}; + +use anyhow::{Context, Result}; +use hal::buffer::Usage; +use std::mem::ManuallyDrop; + +/// Initial size of vertex buffer. TODO: Way of overriding this +pub const INITIAL_VERT_SIZE: u64 = 3 * 3000; + +/// Initial size of index buffer. TODO: Way of overriding this +pub const INITIAL_INDEX_SIZE: u64 = 3000; + +/// A vertex and index buffer set for drawing +pub struct DrawBuffers<'a, T: Sized, P: MemoryPool, SP: MemoryPool> { + pub vertex_buffer: ManuallyDrop>, + pub index_buffer: ManuallyDrop>, +} + +impl<'a, T, P, SP> DrawBuffers<'a, T, P, SP> +where + P: MemoryPool, + SP: MemoryPool, + SP::Block: MappableBlock, +{ + /// Create a new set of drawbuffers given a render context. + /// This will allocate memory from `P` and `SP`, and currently has a fixed size (WIP). + pub fn from_context(context: &mut RenderingContext) -> Result { + let vert = StagedBuffer::from_context(context, Usage::VERTEX, INITIAL_VERT_SIZE) + .context("Error creating vertex buffer")?; + let index = StagedBuffer::from_context(context, Usage::INDEX, INITIAL_INDEX_SIZE) + .context("Error creating index buffer")?; + + Ok(DrawBuffers { + vertex_buffer: ManuallyDrop::new(vert), + index_buffer: ManuallyDrop::new(index), + }) + } + + /// Destroy all Vulkan objects. Should be called before dropping. + pub fn deactivate(self, context: &mut RenderingContext) { + unsafe { + use core::ptr::read; + + ManuallyDrop::into_inner(read(&self.vertex_buffer)).deactivate(context); + ManuallyDrop::into_inner(read(&self.index_buffer)).deactivate(context); + } + } +} diff --git a/stockton-skeleton/src/buffers/draw_buffers.rs b/stockton-skeleton/src/buffers/draw_buffers.rs deleted file mode 100644 index 5baec92..0000000 --- a/stockton-skeleton/src/buffers/draw_buffers.rs +++ /dev/null @@ -1,43 +0,0 @@ -//! A vertex and index buffer set for drawing - -use super::StagedBuffer; -use crate::types::*; - -use anyhow::{Context, Result}; -use hal::buffer::Usage; -use std::mem::ManuallyDrop; - -/// Initial size of vertex buffer. TODO: Way of overriding this -pub const INITIAL_VERT_SIZE: u64 = 3 * 3000; - -/// Initial size of index buffer. TODO: Way of overriding this -pub const INITIAL_INDEX_SIZE: u64 = 3000; - -/// The buffers used for drawing, ie index and vertex buffer -pub struct DrawBuffers<'a, T: Sized> { - pub vertex_buffer: ManuallyDrop>, - pub index_buffer: ManuallyDrop>, -} - -impl<'a, T> DrawBuffers<'a, T> { - pub fn new(device: &mut DeviceT, adapter: &Adapter) -> Result> { - let vert = StagedBuffer::new(device, adapter, Usage::VERTEX, INITIAL_VERT_SIZE) - .context("Error creating vertex buffer")?; - let index = StagedBuffer::new(device, adapter, Usage::INDEX, INITIAL_INDEX_SIZE) - .context("Error creating index buffer")?; - - Ok(DrawBuffers { - vertex_buffer: ManuallyDrop::new(vert), - index_buffer: ManuallyDrop::new(index), - }) - } - - pub fn deactivate(self, device: &mut DeviceT) { - unsafe { - use core::ptr::read; - - ManuallyDrop::into_inner(read(&self.vertex_buffer)).deactivate(device); - ManuallyDrop::into_inner(read(&self.index_buffer)).deactivate(device); - } - } -} diff --git a/stockton-skeleton/src/buffers/image.rs b/stockton-skeleton/src/buffers/image.rs new file mode 100644 index 0000000..34a0a37 --- /dev/null +++ b/stockton-skeleton/src/buffers/image.rs @@ -0,0 +1,342 @@ +//! An image with memory bound to it and an image view into its entirety. +//! This is useful for most types of images. +//! ```rust +//! # use anyhow::Result; +//! # use crate::{mem::DrawAttachments, context::RenderingContext}; +//! fn create_depth_buffer( +//! context: &mut RenderingContext, +//! ) -> Result> { +//! BoundImageView::from_context( +//! context, +//! &ImageSpec { +//! width: 10, +//! height: 10, +//! format: Format::D32Sfloat, +//! usage: Usage::DEPTH_STENCIL_ATTACHMENT, +//! }, +//! ) +//! } +/// ``` +use std::mem::ManuallyDrop; + +use crate::{ + context::RenderingContext, + error::LockPoisoned, + mem::{Block, MemoryPool}, + types::*, + utils::get_pixel_size, +}; +use anyhow::{Context, Result}; +use hal::{ + format::{Aspects, Format, Swizzle}, + image::{SamplerDesc, SubresourceRange, Usage, ViewKind}, + memory::SparseFlags, +}; + +pub const COLOR_RESOURCES: SubresourceRange = SubresourceRange { + aspects: Aspects::COLOR, + level_start: 0, + level_count: Some(1), + layer_start: 0, + layer_count: Some(1), +}; + +pub const DEPTH_RESOURCES: SubresourceRange = SubresourceRange { + aspects: Aspects::DEPTH, + level_start: 0, + level_count: Some(1), + layer_start: 0, + layer_count: Some(1), +}; + +/// An image with memory bound to it and an image view into its entirety +/// Memory is allocated from the memory pool P, see [`crate::mem`] +pub struct BoundImageView { + mem: ManuallyDrop, + img: ManuallyDrop, + img_view: ManuallyDrop, + unpadded_row_size: u32, + row_size: u32, + height: u32, +} + +impl BoundImageView

{ + /// Create an uninitialised image using memory from the specified pool + pub fn from_context(context: &mut RenderingContext, spec: &ImageSpec) -> Result { + // Ensure the memory pool exists before we get a reference to it + context + .ensure_memory_pool::

() + .context("Error creating memory pool requested for BoundImageView")?; + let mut allocator = context + .existing_memory_pool::

() + .unwrap() + .write() + .map_err(|_| LockPoisoned::MemoryPool)?; + + let mut device = context.device().write().map_err(|_| LockPoisoned::Device)?; + let row_alignment_mask = context + .physical_device_properties() + .limits + .optimal_buffer_copy_pitch_alignment as u32 + - 1; + Self::from_device_allocator(&mut device, &mut allocator, row_alignment_mask, spec) + } + + /// Create an uninitialised image using memory from the specified pool, but using a much less convenient signature. + /// Use this when you don't have access to the full context. + pub fn from_device_allocator( + device: &mut DeviceT, + pool: &mut P, + row_alignment_mask: u32, + spec: &ImageSpec, + ) -> Result { + // Calculate buffer size & alignment + let initial_row_size = get_pixel_size(spec.format) * spec.width; + let row_size = (initial_row_size + row_alignment_mask) & !row_alignment_mask; + debug_assert!(row_size >= initial_row_size); + + unsafe { + use hal::image::{Kind, Tiling, ViewCapabilities}; + + // Create the image + let mut img = device + .create_image( + Kind::D2(spec.width, spec.height, 1, 1), + 1, + spec.format, + Tiling::Optimal, + spec.usage, + SparseFlags::empty(), + ViewCapabilities::empty(), + ) + .context("Error creating image")?; + + // Get memory requirements + let requirements = device.get_image_requirements(&img); + + // Allocate memory + let (mem, _) = pool + .alloc(&device, requirements.size, requirements.alignment) + .context("Error allocating memory")?; + + // Bind memory + device + .bind_image_memory(mem.memory(), mem.range().start, &mut img) + .context("Error binding memory to image")?; + + // Create image view + let img_view = device + .create_image_view( + &img, + ViewKind::D2, + spec.format, + Swizzle::NO, + spec.usage, + spec.resources.clone(), + ) + .context("Error creating image view")?; + + Ok(Self { + mem: ManuallyDrop::new(mem), + img: ManuallyDrop::new(img), + img_view: ManuallyDrop::new(img_view), + row_size, + height: spec.height, + unpadded_row_size: spec.width, + }) + } + } + + /// Destroy all vulkan objects. Must be called before dropping. + pub fn deactivate_with_context(self, context: &mut RenderingContext) { + let mut device = context + .device() + .write() + .map_err(|_| LockPoisoned::Device) + .unwrap(); + let mut pool = context + .existing_memory_pool::

() + .unwrap() + .write() + .unwrap(); + + self.deactivate_with_device_pool(&mut device, &mut pool); + } + + /// Destroy all vulkan objects. Must be called before dropping. + pub fn deactivate_with_device_pool(self, device: &mut DeviceT, pool: &mut P) { + use std::ptr::read; + unsafe { + device.destroy_image_view(read(&*self.img_view)); + device.destroy_image(read(&*self.img)); + pool.free(&device, read(&*self.mem)); + } + } + + /// Get a reference to the bound image. + pub fn img(&self) -> &ImageT { + &*self.img + } + + /// Get a reference to the view of the bound image. + pub fn img_view(&self) -> &ImageViewT { + &*self.img_view + } + + /// Get a reference to the memory used by the bound image. + pub fn mem(&self) -> &

::Block { + &*self.mem + } + + /// Get the bound image view's row size. + pub fn row_size(&self) -> u32 { + self.row_size + } + + /// Get the bound image view's height. + pub fn height(&self) -> u32 { + self.height + } + + /// Get the bound image view's unpadded row size. + pub fn unpadded_row_size(&self) -> u32 { + self.unpadded_row_size + } +} + +/// A [`self::BoundImageView`] and accompanying sampler. +pub struct SampledImage { + bound_image: ManuallyDrop>, + sampler: ManuallyDrop, +} + +impl SampledImage

{ + /// Create an uninitialised image using memory from the specified pool + pub fn from_context( + context: &mut RenderingContext, + spec: &ImageSpec, + sampler_desc: &SamplerDesc, + ) -> Result { + // Ensure the memory pool exists before we get a reference to it + context + .ensure_memory_pool::

() + .context("Error creating memory pool requested for BoundImageView")?; + let mut allocator = context + .existing_memory_pool::

() + .unwrap() + .write() + .map_err(|_| LockPoisoned::MemoryPool)?; + + let mut device = context.device().write().map_err(|_| LockPoisoned::Device)?; + let row_alignment_mask = context + .physical_device_properties() + .limits + .optimal_buffer_copy_pitch_alignment as u32 + - 1; + + Self::from_device_allocator( + &mut device, + &mut allocator, + row_alignment_mask, + spec, + sampler_desc, + ) + } + + /// Create an uninitialised image and sampler using memory from the specified pool, but using a much less convenient signature. + /// Use this when you don't have access to the full context. + pub fn from_device_allocator( + device: &mut DeviceT, + pool: &mut P, + row_alignment_mask: u32, + spec: &ImageSpec, + sampler_desc: &SamplerDesc, + ) -> Result { + let sampler = unsafe { device.create_sampler(sampler_desc) }?; + + Ok(SampledImage { + bound_image: ManuallyDrop::new(BoundImageView::from_device_allocator( + device, + pool, + row_alignment_mask, + spec, + )?), + sampler: ManuallyDrop::new(sampler), + }) + } + + /// Destroy all vulkan objects. Must be called before dropping. + pub fn deactivate_with_context(self, context: &mut RenderingContext) { + let mut device = context + .device() + .write() + .map_err(|_| LockPoisoned::Device) + .unwrap(); + let mut pool = context + .existing_memory_pool::

() + .unwrap() + .write() + .unwrap(); + + self.deactivate_with_device_pool(&mut device, &mut pool); + } + + /// Destroy all vulkan objects. Must be called before dropping. + pub fn deactivate_with_device_pool(self, device: &mut DeviceT, pool: &mut P) { + unsafe { + use std::ptr::read; + read(&*self.bound_image).deactivate_with_device_pool(device, pool); + device.destroy_sampler(read(&*self.sampler)); + } + } + + /// Get a reference to the bound image object. + pub fn bound_image(&self) -> &BoundImageView

{ + &self.bound_image + } + + /// Get a reference to the bound image. + pub fn img(&self) -> &ImageT { + self.bound_image.img() + } + + /// Get a reference to the view of the bound image. + pub fn img_view(&self) -> &ImageViewT { + self.bound_image.img_view() + } + + /// Get the bound image view's row size. + pub fn row_size(&self) -> u32 { + self.bound_image.row_size() + } + + /// Get the bound image view's unpadded row size. + pub fn unpadded_row_size(&self) -> u32 { + self.bound_image.unpadded_row_size() + } + + /// Get the bound image view's height. + pub fn height(&self) -> u32 { + self.bound_image.height() + } + + /// Get a reference to the memory used by the bound image. + pub fn mem(&self) -> &

::Block { + self.bound_image.mem() + } + + /// Get a reference to the sampler. + pub fn sampler(&self) -> &SamplerT { + &self.sampler + } +} + +/// Information needed to create an image. +#[derive(Debug, Clone)] +pub struct ImageSpec { + pub width: u32, + pub height: u32, + pub format: Format, + pub usage: Usage, + pub resources: SubresourceRange, +} diff --git a/stockton-skeleton/src/buffers/mod.rs b/stockton-skeleton/src/buffers/mod.rs index 74c5aab..08b2356 100644 --- a/stockton-skeleton/src/buffers/mod.rs +++ b/stockton-skeleton/src/buffers/mod.rs @@ -1,63 +1,6 @@ -//! All sorts of buffers +//! Convenience types wrapping buffers -use std::ops::IndexMut; - -use crate::{error::EnvironmentError, types::*}; - -use anyhow::{Context, Result}; -use hal::{ - buffer::Usage, - memory::{Properties, SparseFlags}, - MemoryTypeId, -}; - -mod dedicated_image; -mod draw_buffers; -mod staged; - -pub use dedicated_image::*; -pub use draw_buffers::*; -pub use staged::*; - -/// Create a buffer of the given specifications, allocating more device memory. -// TODO: Use a different memory allocator? -pub(crate) fn create_buffer( - device: &mut DeviceT, - adapter: &Adapter, - usage: Usage, - properties: Properties, - size: u64, -) -> Result<(BufferT, MemoryT)> { - let mut buffer = unsafe { device.create_buffer(size, usage, SparseFlags::empty()) } - .context("Error creating buffer")?; - - let requirements = unsafe { device.get_buffer_requirements(&buffer) }; - let memory_type_id = adapter - .physical_device - .memory_properties() - .memory_types - .iter() - .enumerate() - .find(|&(id, memory_type)| { - requirements.type_mask & (1 << id) != 0 && memory_type.properties.contains(properties) - }) - .map(|(id, _)| MemoryTypeId(id)) - .ok_or(EnvironmentError::NoMemoryTypes)?; - - let memory = unsafe { device.allocate_memory(memory_type_id, requirements.size) } - .context("Error allocating memory")?; - - unsafe { device.bind_buffer_memory(&memory, 0, &mut buffer) } - .context("Error binding memory to buffer")?; - - Ok((buffer, memory)) -} - -/// A buffer that can be modified by the CPU -pub trait ModifiableBuffer: IndexMut { - /// Get a handle to the underlying GPU buffer - fn get_buffer(&mut self) -> &BufferT; - - /// Record the command(s) required to commit changes to this buffer to the given command buffer. - fn record_commit_cmds(&mut self, cmd_buffer: &mut CommandBufferT) -> Result<()>; -} +pub mod draw; +pub mod image; +pub mod staged; +pub mod staging; diff --git a/stockton-skeleton/src/buffers/staged.rs b/stockton-skeleton/src/buffers/staged.rs index 71b5204..ec42102 100644 --- a/stockton-skeleton/src/buffers/staged.rs +++ b/stockton-skeleton/src/buffers/staged.rs @@ -1,7 +1,11 @@ //! A buffer that can be written to by the CPU using staging memory -use super::{create_buffer, ModifiableBuffer}; -use crate::types::*; +use crate::{ + context::RenderingContext, + error::LockPoisoned, + mem::{Block, MappableBlock, MemoryPool}, + types::*, +}; use core::mem::{size_of, ManuallyDrop}; use std::{ @@ -10,72 +14,88 @@ use std::{ }; use anyhow::{Context, Result}; -use hal::{ - buffer::Usage, - command::BufferCopy, - memory::{Properties, Segment}, -}; +use hal::{buffer::Usage, command::BufferCopy, memory::SparseFlags}; -/// A GPU buffer that is written to using a staging buffer -pub struct StagedBuffer<'a, T: Sized> { +/// A GPU buffer that is written to using a staging buffer. The staging buffer and the GPU buffers are the same size, +/// so this isn't optimal in a lot of cases. +pub struct StagedBuffer<'a, T: Sized, P: MemoryPool, SP: MemoryPool> { /// CPU-visible buffer staged_buffer: ManuallyDrop, /// CPU-visible memory - staged_memory: ManuallyDrop, + staged_memory: ManuallyDrop, /// GPU Buffer buffer: ManuallyDrop, /// GPU Memory - memory: ManuallyDrop, + memory: ManuallyDrop, /// Where staged buffer is mapped in CPU memory staged_mapped_memory: &'a mut [T], /// The highest index in the buffer that's been written to. - pub highest_used: usize, + highest_used: usize, } -impl<'a, T: Sized> StagedBuffer<'a, T> { - /// size is the size in T - pub fn new(device: &mut DeviceT, adapter: &Adapter, usage: Usage, size: u64) -> Result { +impl<'a, T, P, SP> StagedBuffer<'a, T, P, SP> +where + T: Sized, + P: MemoryPool, + SP: MemoryPool, + SP::Block: MappableBlock, +{ + /// Create an new staged buffer from the given rendering context. + /// `size` is the size in T. The GPU buffer's usage will be `usage | Usage::TRANSFER_DST` and the staging buffer's usage will be `Usage::TRANSFER_SRC`. + pub fn from_context(context: &mut RenderingContext, usage: Usage, size: u64) -> Result { // Convert size to bytes let size_bytes = size * size_of::() as u64; - // Get CPU-visible buffer - let (staged_buffer, mut staged_memory) = create_buffer( - device, - adapter, - Usage::TRANSFER_SRC, - Properties::CPU_VISIBLE, - size_bytes, - ) - .context("Error creating staging buffer")?; - - // Get GPU Buffer - let (buffer, memory) = create_buffer( - device, - adapter, - Usage::TRANSFER_DST | usage, - Properties::DEVICE_LOCAL | Properties::COHERENT, - size_bytes, - ) - .context("Error creating GPU buffer")?; - - // Map it somewhere and get a slice to that memory + // Make sure our memory pools exist + context.ensure_memory_pool::

()?; + context.ensure_memory_pool::()?; + + // Lock the device and memory pools + let mut device = context.device().write().map_err(|_| LockPoisoned::Device)?; + let mut mempool = context + .existing_memory_pool::

() + .unwrap() + .write() + .map_err(|_| LockPoisoned::MemoryPool)?; + let mut staging_mempool = context + .existing_memory_pool::() + .unwrap() + .write() + .map_err(|_| LockPoisoned::MemoryPool)?; + + // Staging buffer + let (staged_buffer, mut staged_memory) = unsafe { + create_buffer( + &mut device, + size_bytes, + Usage::TRANSFER_SRC, + &mut *staging_mempool, + ) + .context("Error creating staging buffer")? + }; + + // GPU Buffer + let (buffer, memory) = unsafe { + create_buffer( + &mut device, + size_bytes, + usage | Usage::TRANSFER_DST, + &mut *mempool, + ) + .context("Error creating GPU buffer")? + }; + + // Map the staging buffer somewhere let staged_mapped_memory = unsafe { - let ptr = device - .map_memory( - &mut staged_memory, - Segment { - offset: 0, - size: Some(size_bytes), - }, - ) - .context("Error mapping staged memory")?; - - std::slice::from_raw_parts_mut(ptr as *mut T, size.try_into()?) + std::slice::from_raw_parts_mut( + std::mem::transmute(staged_memory.map(&mut device, 0..size_bytes)?), + size.try_into()?, + ) }; Ok(StagedBuffer { @@ -88,26 +108,39 @@ impl<'a, T: Sized> StagedBuffer<'a, T> { }) } - /// Call this before dropping - pub(crate) fn deactivate(mut self, device: &mut DeviceT) { + /// Destroy all Vulkan objects. Should be called before dropping. + pub fn deactivate(mut self, context: &mut RenderingContext) { unsafe { - device.unmap_memory(&mut self.staged_memory); + let device = &mut *context.device().write().unwrap(); - device.free_memory(ManuallyDrop::take(&mut self.staged_memory)); - device.destroy_buffer(ManuallyDrop::take(&mut self.staged_buffer)); + self.staged_memory.unmap(device).unwrap(); + + context + .existing_memory_pool::() + .unwrap() + .write() + .unwrap() + .free(device, ManuallyDrop::take(&mut self.staged_memory)); - device.free_memory(ManuallyDrop::take(&mut self.memory)); + context + .existing_memory_pool::

() + .unwrap() + .write() + .unwrap() + .free(device, ManuallyDrop::take(&mut self.memory)); + + device.destroy_buffer(ManuallyDrop::take(&mut self.staged_buffer)); device.destroy_buffer(ManuallyDrop::take(&mut self.buffer)); }; } -} -impl<'a, T: Sized> ModifiableBuffer for StagedBuffer<'a, T> { - fn get_buffer(&mut self) -> &BufferT { + /// Get a handle to the underlying GPU buffer + pub fn get_buffer(&mut self) -> &BufferT { &self.buffer } - fn record_commit_cmds(&mut self, buf: &mut CommandBufferT) -> Result<()> { + /// Record the command(s) required to commit changes to this buffer to the given command buffer. + pub fn record_commit_cmds(&mut self, buf: &mut CommandBufferT) -> Result<()> { unsafe { buf.copy_buffer( &self.staged_buffer, @@ -122,9 +155,35 @@ impl<'a, T: Sized> ModifiableBuffer for StagedBuffer<'a, T> { Ok(()) } + + /// Get the highest byte in this buffer that's been written to (by the CPU) + pub fn highest_used(&self) -> usize { + self.highest_used + } +} + +/// Used internally to create a buffer from a memory pool +unsafe fn create_buffer( + device: &mut DeviceT, + size: u64, + usage: Usage, + mempool: &mut P, +) -> Result<(BufferT, P::Block)> { + let mut buffer = device + .create_buffer(size, usage, SparseFlags::empty()) + .context("Error creating buffer")?; + let req = device.get_buffer_requirements(&buffer); + + let (memory, _) = mempool.alloc(device, size, req.alignment)?; + + device + .bind_buffer_memory(memory.memory(), 0, &mut buffer) + .context("Error binding memory to buffer")?; + + Ok((buffer, memory)) } -impl<'a, T: Sized> Index for StagedBuffer<'a, T> { +impl<'a, T: Sized, P: MemoryPool, SP: MemoryPool> Index for StagedBuffer<'a, T, P, SP> { type Output = T; fn index(&self, index: usize) -> &Self::Output { @@ -132,7 +191,7 @@ impl<'a, T: Sized> Index for StagedBuffer<'a, T> { } } -impl<'a, T: Sized> IndexMut for StagedBuffer<'a, T> { +impl<'a, T: Sized, P: MemoryPool, SP: MemoryPool> IndexMut for StagedBuffer<'a, T, P, SP> { fn index_mut(&mut self, index: usize) -> &mut Self::Output { if index > self.highest_used { self.highest_used = index; diff --git a/stockton-skeleton/src/buffers/staging.rs b/stockton-skeleton/src/buffers/staging.rs new file mode 100644 index 0000000..5c80f51 --- /dev/null +++ b/stockton-skeleton/src/buffers/staging.rs @@ -0,0 +1,103 @@ +//! A buffer that can be written to by the CPU + +use crate::{ + context::RenderingContext, + error::LockPoisoned, + mem::{Block, MappableBlock, MemoryPool}, + types::*, +}; + +use std::{mem::ManuallyDrop, ops::Range}; + +use anyhow::{Context, Result}; +use hal::{buffer::Usage, memory::SparseFlags}; + +/// A buffer that can be written to by the CPU. Usage will be `Usage::TRANSFER_SRC`. +pub struct StagingBuffer { + buf: ManuallyDrop, + mem: ManuallyDrop, +} + +impl

StagingBuffer

+where + P: MemoryPool, + P::Block: MappableBlock, +{ + /// Create a new staging buffer from the given RenderingContext. `size` is in bytes. + pub fn from_context(context: &mut RenderingContext, size: u64) -> Result { + context.ensure_memory_pool::

()?; + + let mut device = context.device().write().map_err(|_| LockPoisoned::Device)?; + let mut mempool = context + .existing_memory_pool() + .unwrap() + .write() + .map_err(|_| LockPoisoned::MemoryPool)?; + + Self::from_device_pool(&mut device, &mut mempool, size) + } + + /// Create a new staging buffer from the given device and memory pool. `size` is in bytes. + pub fn from_device_pool(device: &mut DeviceT, mempool: &mut P, size: u64) -> Result { + let mut buffer = + unsafe { device.create_buffer(size, Usage::TRANSFER_SRC, SparseFlags::empty()) } + .context("Error creating buffer")?; + + let requirements = unsafe { device.get_buffer_requirements(&buffer) }; + + let (memory, _) = mempool + .alloc(device, requirements.size, requirements.alignment) + .context("Error allocating staging memory")?; + + unsafe { device.bind_buffer_memory(memory.memory(), memory.range().start, &mut buffer) } + .context("Error binding staging memory to buffer")?; + + Ok(StagingBuffer { + buf: ManuallyDrop::new(buffer), + mem: ManuallyDrop::new(memory), + }) + } + + /// Map the given range to CPU-visible memory, returning a pointer to the start of that range. + /// inner_range is local to this block of memory, not to the container as a whole. + pub fn map(&mut self, device: &mut DeviceT, inner_range: Range) -> Result<*mut u8> { + Ok(<

::Block>::map( + &mut *self.mem, + device, + inner_range, + )?) + } + + /// Remove any mappings present for this staging buffer. + pub unsafe fn unmap(&mut self, device: &mut DeviceT) -> Result<()> { + self.mem.unmap(device) + } + + pub fn deactivate_context(self, context: &mut RenderingContext) { + let mut device = context.device().write().unwrap(); + let mut mempool = context.existing_memory_pool().unwrap().write().unwrap(); + + self.deactivate_device_pool(&mut device, &mut mempool) + } + + /// Destroy all vulkan objects. This should be called before dropping + pub fn deactivate_device_pool(self, device: &mut DeviceT, mempool: &mut P) { + unsafe { + use std::ptr::read; + // Destroy buffer + device.destroy_buffer(read(&*self.buf)); + // Free memory + mempool.free(device, read(&*self.mem)); + } + } + + /// Get a reference to the staging buffer's memory. + pub fn mem(&self) -> &P::Block { + &self.mem + } + + /// Get a reference to the staging buffer. + pub fn buf(&self) -> &ManuallyDrop { + &self.buf + } +} diff --git a/stockton-skeleton/src/builders/pipeline.rs b/stockton-skeleton/src/builders/pipeline.rs index f68d9d6..9f4937f 100644 --- a/stockton-skeleton/src/builders/pipeline.rs +++ b/stockton-skeleton/src/builders/pipeline.rs @@ -1,5 +1,7 @@ use super::{renderpass::RenderpassSpec, shader::ShaderDesc}; -use crate::{error::EnvironmentError, target::SwapchainProperties, types::*}; +use crate::{ + error::EnvironmentError, target::SwapchainProperties, types::*, utils::get_pixel_size, +}; use std::{mem::ManuallyDrop, ops::Range}; @@ -33,23 +35,15 @@ impl VertexBufferSpec { format: *format, }, }); - offset += get_size(*format); + offset += get_pixel_size(*format); } v } pub fn stride(&self) -> ElemStride { - self.attributes.iter().fold(0, |x, f| x + get_size(*f)) - } -} - -fn get_size(f: Format) -> u32 { - match f { - Format::Rgb32Sfloat => 4 * 3, - Format::R32Sint => 4, - Format::Rg32Sfloat => 4 * 2, - Format::Rgba32Sfloat => 4 * 4, - _ => unimplemented!("dont know size of format {:?}", f), + self.attributes + .iter() + .fold(0, |x, f| x + get_pixel_size(*f)) } } diff --git a/stockton-skeleton/src/context.rs b/stockton-skeleton/src/context.rs index 5e2d3a3..be627f2 100644 --- a/stockton-skeleton/src/context.rs +++ b/stockton-skeleton/src/context.rs @@ -2,13 +2,15 @@ //! This relies on draw passes for the actual drawing logic. use std::{ + any::{Any, TypeId}, + collections::HashMap, mem::ManuallyDrop, ptr::read, sync::{Arc, RwLock}, }; use anyhow::{Context, Result}; -use hal::pool::CommandPoolCreateFlags; +use hal::{pool::CommandPoolCreateFlags, PhysicalDeviceProperties}; use log::debug; use winit::window::Window; @@ -21,16 +23,15 @@ use super::{ use crate::{ draw_passes::Singular, error::{EnvironmentError, LockPoisoned}, + mem::MemoryPool, types::*, }; use stockton_types::Session; -/// Contains all the hal related stuff. -/// In the end, this takes in a depth-sorted list of faces and a map file and renders them. -// TODO: Settings for clear colour, buffer sizes, etc +/// Contains most root vulkan objects, and some precalculated info such as best formats to use. +/// In most cases, this and the DrawPass should contain all vulkan objects present. pub struct RenderingContext { - // Parents for most of these things /// Vulkan Instance instance: ManuallyDrop, @@ -40,6 +41,9 @@ pub struct RenderingContext { /// Adapter we're using adapter: Adapter, + /// The properties of the physical device we're using + physical_device_properties: PhysicalDeviceProperties, + /// Swapchain and stuff target_chain: ManuallyDrop, @@ -47,12 +51,17 @@ pub struct RenderingContext { /// The command pool used for our buffers cmd_pool: ManuallyDrop, + /// The queue negotiator to use queue_negotiator: QueueNegotiator, /// The queue to use for drawing queue: Arc>, + /// Number of pixels per standard point pixels_per_point: f32, + + /// The list of memory pools + memory_pools: HashMap>, } impl RenderingContext { @@ -164,6 +173,7 @@ impl RenderingContext { instance: ManuallyDrop::new(instance), device: device_lock, + physical_device_properties: adapter.physical_device.properties(), adapter, queue_negotiator, @@ -172,8 +182,8 @@ impl RenderingContext { target_chain: ManuallyDrop::new(target_chain), cmd_pool: ManuallyDrop::new(cmd_pool), - // pixels_per_point: window.scale_factor() as f32, pixels_per_point: window.scale_factor() as f32, + memory_pools: HashMap::new(), }) } @@ -259,6 +269,36 @@ impl RenderingContext { pub fn queue_negotiator_mut(&mut self) -> &mut QueueNegotiator { &mut self.queue_negotiator } + + /// Get a reference to the physical device's properties. + pub fn physical_device_properties(&self) -> &PhysicalDeviceProperties { + &self.physical_device_properties + } + + /// Get the specified memory pool, lazily initialising it if it's not yet present + pub fn memory_pool<'a, P: MemoryPool>(&'a mut self) -> Result<&'a Arc>> { + self.ensure_memory_pool::

()?; + Ok(self.existing_memory_pool::

().unwrap()) + } + + /// Ensure the specified memory pool is initialised. + pub fn ensure_memory_pool(&mut self) -> Result<()> { + let tid = TypeId::of::

(); + if !self.memory_pools.contains_key(&tid) { + self.memory_pools + .insert(tid, Box::new(P::from_context(self)?)); + } + Ok(()) + } + + /// Get the specified memory pool, returning None if it's not yet present + /// You should only use this when you're certain it exists, such as when freeing memory + /// allocated from that pool + pub fn existing_memory_pool(&self) -> Option<&Arc>> { + self.memory_pools + .get(&TypeId::of::

()) + .map(|x| x.downcast_ref().unwrap()) + } } impl core::ops::Drop for RenderingContext { @@ -267,6 +307,8 @@ impl core::ops::Drop for RenderingContext { self.device.write().unwrap().wait_idle().unwrap(); } + // TODO: Better deactivation code + unsafe { let mut device = self.device.write().unwrap(); diff --git a/stockton-skeleton/src/error.rs b/stockton-skeleton/src/error.rs index 1f57892..6d7e7ad 100644 --- a/stockton-skeleton/src/error.rs +++ b/stockton-skeleton/src/error.rs @@ -15,6 +15,9 @@ pub enum LockPoisoned { #[error("Other lock poisoned")] Other, + + #[error("Memory pool lock poisoned")] + MemoryPool, } /// Indicates the given property has no acceptable values @@ -43,6 +46,15 @@ pub enum EnvironmentError { #[error("No suitable queues")] NoQueues, + + #[error("Memory pool missing")] + MemoryPoolMissing, +} + +#[derive(Debug, Error)] +pub enum UsageError { + #[error("Attempt to create mappable memory block from non-mappable memory")] + NonMappableMemory, } /// Indicates an issue with the level object being used diff --git a/stockton-skeleton/src/lib.rs b/stockton-skeleton/src/lib.rs index 3212873..785fb30 100644 --- a/stockton-skeleton/src/lib.rs +++ b/stockton-skeleton/src/lib.rs @@ -11,6 +11,7 @@ pub mod builders; pub mod context; pub mod draw_passes; pub mod error; +pub mod mem; pub mod queue_negotiator; mod target; pub mod texture; diff --git a/stockton-skeleton/src/mem.rs b/stockton-skeleton/src/mem.rs new file mode 100644 index 0000000..af0a42b --- /dev/null +++ b/stockton-skeleton/src/mem.rs @@ -0,0 +1,368 @@ +//! Used to represent access different memory 'pools'. +//! Ideally, each pool is optimised for a specific use case. +//! You can implement your own pools using whatever algorithm you'd like. You just need to implement [`MemoryPool`] and optionally [`Block`], then access it +//! using [`RenderingContext.pool_allocator`] +//! Alternatively, some default memory pools are availble when the feature `rendy_pools` is used (on by default). + +use crate::{context::RenderingContext, types::*}; + +use std::{ + ops::Range, + sync::{Arc, RwLock}, +}; + +use anyhow::Result; +use hal::memory::Properties; + +/// An allocator whose memory and allocation pattern is optimised for a specific use case. +pub trait MemoryPool: Send + Sync + 'static { + /// The block returned by this pool + type Block: Block + Send + Sync; + + /// Create a new memory pool from the given context + /// This is called to lazily initialise the memory pool when it is first requested. + /// It can do any sort of filtering on memory types required. + fn from_context(context: &RenderingContext) -> Result>>; + + /// Allocate block of memory. + /// On success returns allocated block and amount of memory consumed from device. + /// The returned block must not overlap with any other allocated block, the start of it must be `0 mod(align)`, + /// and it must be at least `size` bytes. + fn alloc(&mut self, device: &DeviceT, size: u64, align: u64) -> Result<(Self::Block, u64)>; + + /// Free block of memory. + /// Returns amount of memory returned to the device. + /// If the given block was not allocated from this pool, this should be a no-op and should return 0. + fn free(&mut self, device: &DeviceT, block: Self::Block) -> u64; + + /// Deactivate this memory pool, freeing any allocated memory objects. + fn deactivate(self, context: &mut RenderingContext); +} + +/// Block that owns a `Range` of the `Memory`. +/// Provides access to safe memory range mapping. +pub trait Block { + /// Get memory properties of the block. + fn properties(&self) -> Properties; + + /// Get raw memory object. + fn memory(&self) -> &MemoryT; + + /// Get memory range owned by this block. + fn range(&self) -> Range; + + /// Get size of the block. + fn size(&self) -> u64 { + let range = self.range(); + range.end - range.start + } +} + +/// An additional trait for [`Block`]s that can be mapped to CPU-visible memory. +/// +/// This should only be implemented for blocks that are *guaranteed* to be visible to the CPU +/// and may panic if this is not the case. +pub trait MappableBlock: Block { + /// Attempt to map this block to CPU-visible memory. + /// `inner_range` is counted from only inside this block, not the wider memory object this block is a part of + fn map(&mut self, device: &mut DeviceT, inner_range: Range) -> Result<*mut u8>; + + /// Unmap this block from CPU-visible memory. + /// If this block is not mapped, this should be a no-op. + /// Implementors should ensure that this does not accidentally unmap other blocks using the same memory block. + fn unmap(&mut self, device: &mut DeviceT) -> Result<()>; +} + +#[cfg(feature = "rendy-pools")] +mod rendy { + use super::*; + + use crate::{ + error::{EnvironmentError, LockPoisoned, UsageError}, + utils::find_memory_type_id, + }; + + use anyhow::{anyhow, Context, Result}; + use hal::{ + format::Format, + memory::{Properties as MemProps, SparseFlags}, + }; + use rendy_memory::{Allocator, Block as RBlock, DynamicAllocator, DynamicBlock, DynamicConfig}; + + /// So we can use rendy blocks as our blocks + impl> Block for T { + fn properties(&self) -> Properties { + >::properties(&self) + } + + fn memory(&self) -> &MemoryT { + >::memory(&self) + } + + fn range(&self) -> Range { + >::range(&self) + } + } + + /// Intended to be used for textures. + /// The allocated memory is guaranteed to be suitable for any colour image with optimal tiling and no extra sparse flags or view capabilities. + pub struct TexturesPool(DynamicAllocator); + impl MemoryPool for TexturesPool { + type Block = DynamicBlock; + + fn alloc(&mut self, device: &DeviceT, size: u64, align: u64) -> Result<(Self::Block, u64)> { + Ok(self.0.alloc(device, size, align)?) + } + + fn free(&mut self, device: &DeviceT, block: Self::Block) -> u64 { + self.0.free(device, block) + } + + fn from_context(context: &RenderingContext) -> Result>> { + let type_mask = unsafe { + use hal::image::{Kind, Tiling, Usage, ViewCapabilities}; + + // We create an empty image with the same format as used for textures + // this is to get the type_mask required, which will stay the same for + // all colour images of the same tiling. (certain memory flags excluded). + + // Size and alignment don't necessarily stay the same, so we're forced to + // guess at the alignment for our allocator. + let device = context.device().write().map_err(|_| LockPoisoned::Device)?; + let img = device + .create_image( + Kind::D2(16, 16, 1, 1), + 1, + Format::Rgba8Srgb, + Tiling::Optimal, + Usage::SAMPLED, + SparseFlags::empty(), + ViewCapabilities::empty(), + ) + .context("Error creating test image to get buffer settings")?; + + let type_mask = device.get_image_requirements(&img).type_mask; + + device.destroy_image(img); + + type_mask + }; + + let allocator = { + let props = MemProps::DEVICE_LOCAL; + + DynamicAllocator::new( + find_memory_type_id(context.adapter(), type_mask, props) + .ok_or(EnvironmentError::NoMemoryTypes)?, + props, + DynamicConfig { + block_size_granularity: 4 * 32 * 32, // 32x32 image + max_chunk_size: u64::pow(2, 63), + min_device_allocation: 4 * 32 * 32, + }, + context + .physical_device_properties() + .limits + .non_coherent_atom_size as u64, + ) + }; + + Ok(Arc::new(RwLock::new(Self(allocator)))) + } + + fn deactivate(self, _context: &mut RenderingContext) { + self.0.dispose(); + } + } + + /// Used for depth buffers. + /// Memory returned is guaranteed to be suitable for any image using `context.target_chain().properties().depth_format` with optimal tiling, and no sparse flags or view capabilities. + pub struct DepthBufferPool(DynamicAllocator); + impl MemoryPool for DepthBufferPool { + type Block = DynamicBlock; + + fn alloc(&mut self, device: &DeviceT, size: u64, align: u64) -> Result<(Self::Block, u64)> { + Ok(self.0.alloc(device, size, align)?) + } + + fn free(&mut self, device: &DeviceT, block: Self::Block) -> u64 { + self.0.free(device, block) + } + + fn from_context(context: &RenderingContext) -> Result>> { + let type_mask = unsafe { + use hal::image::{Kind, Tiling, Usage, ViewCapabilities}; + + let device = context.device().write().map_err(|_| LockPoisoned::Device)?; + let img = device + .create_image( + Kind::D2(16, 16, 1, 1), + 1, + context.target_chain().properties().depth_format, + Tiling::Optimal, + Usage::SAMPLED, + SparseFlags::empty(), + ViewCapabilities::empty(), + ) + .context("Error creating test image to get buffer settings")?; + + let type_mask = device.get_image_requirements(&img).type_mask; + + device.destroy_image(img); + + type_mask + }; + + let allocator = { + let props = MemProps::DEVICE_LOCAL; + + DynamicAllocator::new( + find_memory_type_id(context.adapter(), type_mask, props) + .ok_or(EnvironmentError::NoMemoryTypes)?, + props, + DynamicConfig { + block_size_granularity: 4 * 32 * 32, // 32x32 image + max_chunk_size: u64::pow(2, 63), + min_device_allocation: 4 * 32 * 32, + }, + context + .physical_device_properties() + .limits + .non_coherent_atom_size as u64, + ) + }; + + Ok(Arc::new(RwLock::new(Self(allocator)))) + } + + fn deactivate(self, _context: &mut RenderingContext) { + self.0.dispose() + } + } + + /// Used for staging buffers + pub struct StagingPool(DynamicAllocator); + impl MemoryPool for StagingPool { + type Block = MappableRBlock>; + + fn alloc(&mut self, device: &DeviceT, size: u64, align: u64) -> Result<(Self::Block, u64)> { + let (b, size) = self.0.alloc(device, size, align)?; + Ok((MappableRBlock::new_unchecked(b), size)) + } + + fn free(&mut self, device: &DeviceT, block: Self::Block) -> u64 { + self.0.free(device, block.0) + } + + fn from_context(context: &RenderingContext) -> Result>> { + let allocator = { + let props = MemProps::CPU_VISIBLE | MemProps::COHERENT; + let t = find_memory_type_id(context.adapter(), u32::MAX, props) + .ok_or(EnvironmentError::NoMemoryTypes)?; + DynamicAllocator::new( + t, + props, + DynamicConfig { + block_size_granularity: 4 * 32 * 32, // 32x32 image + max_chunk_size: u64::pow(2, 63), + min_device_allocation: 4 * 32 * 32, + }, + context + .physical_device_properties() + .limits + .non_coherent_atom_size as u64, + ) + }; + + Ok(Arc::new(RwLock::new(StagingPool(allocator)))) + } + + fn deactivate(self, _context: &mut RenderingContext) { + self.0.dispose() + } + } + + /// Suitable for input data, such as vertices and indices. + pub struct DataPool(DynamicAllocator); + impl MemoryPool for DataPool { + type Block = DynamicBlock; + + fn alloc(&mut self, device: &DeviceT, size: u64, align: u64) -> Result<(Self::Block, u64)> { + Ok(self.0.alloc(device, size, align)?) + } + + fn free(&mut self, device: &DeviceT, block: Self::Block) -> u64 { + self.0.free(device, block) + } + + fn from_context(context: &RenderingContext) -> Result>> { + let allocator = { + let props = MemProps::CPU_VISIBLE | MemProps::COHERENT; + let t = find_memory_type_id(context.adapter(), u32::MAX, props) + .ok_or(EnvironmentError::NoMemoryTypes)?; + DynamicAllocator::new( + t, + props, + DynamicConfig { + block_size_granularity: 4 * 4 * 128, // 128 f32 XYZ[?] vertices + max_chunk_size: u64::pow(2, 63), + min_device_allocation: 4 * 4 * 128, + }, + context + .physical_device_properties() + .limits + .non_coherent_atom_size as u64, + ) + }; + + Ok(Arc::new(RwLock::new(DataPool(allocator)))) + } + + fn deactivate(self, _context: &mut RenderingContext) { + self.0.dispose() + } + } + + /// A rendy memory block that is guaranteed to be CPU visible. + pub struct MappableRBlock>(B); + impl> MappableRBlock { + /// Create a new mappable memory block, returning an error if the block is not CPU visible + pub fn new(block: B) -> Result { + if !block.properties().contains(MemProps::CPU_VISIBLE) { + return Err(anyhow!(UsageError::NonMappableMemory)); + } + Ok(Self::new_unchecked(block)) + } + + /// Create a new mappable memory block, without checking if the block is CPU visible. + pub fn new_unchecked(block: B) -> Self { + Self(block) + } + } + + impl> Block for MappableRBlock { + fn properties(&self) -> MemProps { + self.0.properties() + } + + fn memory(&self) -> &MemoryT { + self.0.memory() + } + + fn range(&self) -> Range { + self.0.range() + } + } + impl> MappableBlock for MappableRBlock { + fn map(&mut self, device: &mut DeviceT, inner_range: Range) -> Result<*mut u8> { + unsafe { Ok(self.0.map(device, inner_range)?.ptr().as_mut()) } + } + + fn unmap(&mut self, device: &mut DeviceT) -> Result<()> { + Ok(self.0.unmap(device)) + } + } +} + +#[cfg(feature = "rendy-pools")] +pub use rendy::*; diff --git a/stockton-skeleton/src/texture/block.rs b/stockton-skeleton/src/texture/block.rs index 5ac3a94..1b195c2 100644 --- a/stockton-skeleton/src/texture/block.rs +++ b/stockton-skeleton/src/texture/block.rs @@ -1,21 +1,22 @@ use super::{loader::BlockRef, repo::BLOCK_SIZE}; -use crate::types::*; +use crate::{buffers::image::SampledImage, mem::MemoryPool, types::*}; use arrayvec::ArrayVec; -use rendy_memory::{Allocator, Block}; use std::{iter::once, mem::ManuallyDrop}; -pub struct TexturesBlock> { +/// A block of loaded textures +pub struct TexturesBlock { pub id: BlockRef, pub descriptor_set: ManuallyDrop, - pub imgs: ArrayVec<[LoadedImage; BLOCK_SIZE]>, + pub imgs: ArrayVec<[SampledImage; BLOCK_SIZE]>, } -impl> TexturesBlock { - pub fn deactivate>( +impl TexturesBlock { + /// Destroy all Vulkan objects. Must be called before dropping. + pub fn deactivate( mut self, device: &mut DeviceT, - tex_alloc: &mut T, + tex_alloc: &mut TP, desc_alloc: &mut DescriptorAllocator, ) { unsafe { @@ -27,36 +28,8 @@ impl> TexturesBlock { // Images self.imgs .drain(..) - .map(|x| x.deactivate(device, tex_alloc)) + .map(|x| x.deactivate_with_device_pool(device, tex_alloc)) .for_each(|_| {}); } } } - -pub struct LoadedImage> { - pub mem: ManuallyDrop, - pub img: ManuallyDrop, - pub img_view: ManuallyDrop, - pub sampler: ManuallyDrop, - pub row_size: usize, - pub height: u32, - pub width: u32, -} - -impl> LoadedImage { - pub fn deactivate>( - self, - device: &mut DeviceT, - alloc: &mut T, - ) { - unsafe { - use std::ptr::read; - - device.destroy_image_view(read(&*self.img_view)); - device.destroy_image(read(&*self.img)); - device.destroy_sampler(read(&*self.sampler)); - - alloc.free(device, read(&*self.mem)); - } - } -} diff --git a/stockton-skeleton/src/texture/load.rs b/stockton-skeleton/src/texture/load.rs index 1f33ad5..6cb4f4d 100644 --- a/stockton-skeleton/src/texture/load.rs +++ b/stockton-skeleton/src/texture/load.rs @@ -1,31 +1,31 @@ -use super::{ - block::LoadedImage, block::TexturesBlock, repo::BLOCK_SIZE, resolver::TextureResolver, - staging_buffer::StagingBuffer, LoadableImage, PIXEL_SIZE, +use std::sync::{Arc, RwLock}; + +use super::{block::TexturesBlock, repo::BLOCK_SIZE, resolver::TextureResolver, LoadableImage}; +use crate::{ + buffers::{ + image::{ImageSpec, SampledImage, COLOR_RESOURCES}, + staging::StagingBuffer, + }, + error::LockPoisoned, + mem::{Block, MappableBlock, MemoryPool}, + types::*, }; -use crate::types::*; use anyhow::{Context, Result}; use arrayvec::ArrayVec; use hal::{ - format::{Aspects, Format, Swizzle}, + format::{Aspects, Format}, image::{ - Filter, SamplerDesc, SubresourceLayers, SubresourceRange, Usage as ImgUsage, ViewKind, - WrapMode, + Filter, SamplerDesc, SubresourceLayers, SubresourceRange, Usage as ImgUsage, WrapMode, }, - memory::SparseFlags, - MemoryTypeId, }; -use rendy_memory::{Allocator, Block}; -use std::mem::ManuallyDrop; use thiserror::Error; -#[derive(Error, Debug)] -pub enum TextureLoadError { - #[error("No available resources")] - NoResources, -} - +/// The format used by the texture repo +// TODO: This should be customisable. pub const FORMAT: Format = Format::Rgba8Srgb; + +/// The resources used by each texture. ie one colour aspect pub const RESOURCES: SubresourceRange = SubresourceRange { aspects: Aspects::COLOR, level_start: 0, @@ -33,159 +33,112 @@ pub const RESOURCES: SubresourceRange = SubresourceRange { layer_start: 0, layer_count: Some(1), }; + +/// The layers used by each texture. ie one colour layer pub const LAYERS: SubresourceLayers = SubresourceLayers { aspects: Aspects::COLOR, level: 0, layers: 0..1, }; +/// Configuration required to load a texture pub struct TextureLoadConfig { + /// The resolver to use pub resolver: R, + + /// How to sample the image pub filter: Filter, + + /// How to deal with texture coordinates outside the image. pub wrap_mode: WrapMode, } -pub struct QueuedLoad> { +/// A texture load that has been queued, and is finished when the fence triggers. +pub struct QueuedLoad { pub fence: FenceT, pub buf: CommandBufferT, - pub block: TexturesBlock, - pub staging_bufs: ArrayVec<[StagingBuffer; BLOCK_SIZE]>, + pub block: TexturesBlock, + pub staging_bufs: ArrayVec<[StagingBuffer; BLOCK_SIZE]>, } -impl> QueuedLoad { +impl QueuedLoad { + /// Break down into a tuple pub fn dissolve( self, ) -> ( (FenceT, CommandBufferT), - ArrayVec<[StagingBuffer; BLOCK_SIZE]>, - TexturesBlock, + ArrayVec<[StagingBuffer; BLOCK_SIZE]>, + TexturesBlock, ) { ((self.fence, self.buf), self.staging_bufs, self.block) } } -pub fn tex_size_info(img: &T, obcpa: hal::buffer::Offset) -> (usize, usize) { - let initial_row_size = PIXEL_SIZE * img.width() as usize; - let row_alignment_mask = obcpa as u32 - 1; - - let row_size = ((initial_row_size as u32 + row_alignment_mask) & !row_alignment_mask) as usize; - let total_size = (row_size * (img.height() as usize)) as u64; - debug_assert!(row_size as usize >= initial_row_size); - - (row_size, total_size as usize) -} - -pub fn create_image_view( +/// Create a SampledImage for the given LoadableImage, and load the image data into a StagingBuffer +/// Note that this doesn't queue up transferring from the buffer to the image. +pub unsafe fn load_image( device: &mut DeviceT, - allocator: &mut T, - format: Format, - usage: ImgUsage, - img: &I, -) -> Result<(T::Block, ImageT)> + staging_allocator: &Arc>, + tex_allocator: &Arc>, + obcpa: u32, + img_data: I, + config: &TextureLoadConfig, +) -> Result<(StagingBuffer, SampledImage)> where - T: Allocator, I: LoadableImage, + R: TextureResolver, + SP: MemoryPool, + TP: MemoryPool, + SP::Block: MappableBlock, { - // Make the image - let mut image_ref = unsafe { - use hal::image::{Kind, Tiling, ViewCapabilities}; - - device.create_image( - Kind::D2(img.width(), img.height(), 1, 1), - 1, - format, - Tiling::Optimal, - usage, - SparseFlags::empty(), - ViewCapabilities::empty(), - ) - } - .context("Error creating image")?; + // Create sampled image + let sampled_image = { + let mut tex_allocator = tex_allocator + .write() + .map_err(|_| LockPoisoned::MemoryPool)?; + + SampledImage::from_device_allocator( + device, + &mut *tex_allocator, + obcpa as u32, + &ImageSpec { + width: img_data.width(), + height: img_data.height(), + format: FORMAT, + usage: ImgUsage::TRANSFER_DST | ImgUsage::SAMPLED, + resources: COLOR_RESOURCES, + }, + &SamplerDesc::new(config.filter, config.wrap_mode), + )? + }; - // Allocate memory - let (block, _) = unsafe { - let requirements = device.get_image_requirements(&image_ref); - - allocator.alloc(device, requirements.size, requirements.alignment) - } - .context("Error allocating memory")?; - - unsafe { - device - .bind_image_memory(block.memory(), block.range().start, &mut image_ref) - .context("Error binding memory to image")?; - } + // Create staging buffer + let total_size = sampled_image.bound_image().mem().size(); - Ok((block, image_ref)) -} + let mut staging_buffer = { + let mut staging_allocator = staging_allocator + .write() + .map_err(|_| LockPoisoned::MemoryPool)?; -pub unsafe fn load_image( - device: &mut DeviceT, - staging_allocator: &mut DynamicAllocator, - tex_allocator: &mut DynamicAllocator, - staging_memory_type: MemoryTypeId, - obcpa: u64, - img_data: I, - config: &TextureLoadConfig, -) -> Result<(StagingBuffer, LoadedImage)> { - // Calculate buffer size - let (row_size, total_size) = tex_size_info(&img_data, obcpa); - - // Create staging buffer - let mut staging_buffer = StagingBuffer::new( - device, - staging_allocator, - total_size as u64, - staging_memory_type, - ) - .context("Error creating staging buffer")?; + StagingBuffer::from_device_pool(device, &mut *staging_allocator, total_size as u64) + .context("Error creating staging buffer")? + }; // Write to staging buffer let mapped_memory = staging_buffer - .map_memory(device) + .map(device, 0..total_size) .context("Error mapping staged memory")?; - img_data.copy_into(mapped_memory, row_size); - - staging_buffer.unmap_memory(device); - - // Create image - let (img_mem, img) = create_image_view( - device, - tex_allocator, - FORMAT, - ImgUsage::SAMPLED | ImgUsage::TRANSFER_DST, - &img_data, - ) - .context("Error creating image")?; - - // Create image view - let img_view = device - .create_image_view( - &img, - ViewKind::D2, - FORMAT, - Swizzle::NO, - ImgUsage::SAMPLED | ImgUsage::TRANSFER_DST, - RESOURCES, - ) - .context("Error creating image view")?; - - // Create sampler - let sampler = device - .create_sampler(&SamplerDesc::new(config.filter, config.wrap_mode)) - .context("Error creating sampler")?; - - Ok(( - staging_buffer, - LoadedImage { - mem: ManuallyDrop::new(img_mem), - img: ManuallyDrop::new(img), - img_view: ManuallyDrop::new(img_view), - sampler: ManuallyDrop::new(sampler), - row_size, - height: img_data.height(), - width: img_data.width(), - }, - )) + img_data.copy_into(mapped_memory, sampled_image.row_size() as usize); + + staging_buffer.unmap(device)?; + + Ok((staging_buffer, sampled_image)) +} + +/// Errors that can be encountered when loading a texture. +#[derive(Error, Debug)] +pub enum TextureLoadError { + #[error("No available resources")] + NoResources, } diff --git a/stockton-skeleton/src/texture/loader.rs b/stockton-skeleton/src/texture/loader.rs index 5c85fd3..7f630ab 100644 --- a/stockton-skeleton/src/texture/loader.rs +++ b/stockton-skeleton/src/texture/loader.rs @@ -1,13 +1,23 @@ //! Manages the loading/unloading of textures use super::{ - block::{LoadedImage, TexturesBlock}, - load::{load_image, QueuedLoad, TextureLoadConfig, TextureLoadError, LAYERS, RESOURCES}, + block::TexturesBlock, + load::{ + load_image, QueuedLoad, TextureLoadConfig, TextureLoadError, FORMAT, LAYERS, RESOURCES, + }, repo::BLOCK_SIZE, resolver::TextureResolver, PIXEL_SIZE, }; -use crate::{error::LockPoisoned, types::*, utils::find_memory_type_id}; +use crate::{ + buffers::image::SampledImage, + context::RenderingContext, + error::{EnvironmentError, LockPoisoned}, + mem::{MappableBlock, MemoryPool}, + queue_negotiator::QueueFamilySelector, + types::*, + utils::get_pixel_size, +}; use std::{ array::IntoIter, @@ -26,18 +36,14 @@ use anyhow::{Context, Result}; use arrayvec::ArrayVec; use hal::{ command::{BufferImageCopy, CommandBufferFlags}, - format::{Aspects, Format}, + format::Aspects, image::{Access, Extent, Layout, Offset, SubresourceLayers, SubresourceRange}, - memory::{Barrier, Dependencies, Properties as MemProps, SparseFlags}, + memory::{Barrier, Dependencies}, pso::{Descriptor, DescriptorSetWrite, ImageDescriptorType, PipelineStage, ShaderStageFlags}, - queue::family::QueueFamilyId, - MemoryTypeId, }; use image::{Rgba, RgbaImage}; use log::*; use rendy_descriptor::{DescriptorRanges, DescriptorSetLayoutBinding, DescriptorType}; -use rendy_memory::DynamicConfig; -use thiserror::Error; /// The number of command buffers to have in flight simultaneously. pub const NUM_SIMULTANEOUS_CMDS: usize = 2; @@ -47,9 +53,15 @@ pub type BlockRef = usize; /// Manages the loading/unloading of textures /// This is expected to load the textures, then send the loaded blocks back -pub struct TextureLoader { +pub struct TextureLoader +where + R: TextureResolver, + TP: MemoryPool, + SP: MemoryPool, + SP::Block: MappableBlock, +{ /// Blocks for which commands have been queued and are done loading once the fence is triggered. - commands_queued: ArrayVec<[QueuedLoad; NUM_SIMULTANEOUS_CMDS]>, + commands_queued: ArrayVec<[QueuedLoad; NUM_SIMULTANEOUS_CMDS]>, /// The command buffers used and a fence to go with them buffers: VecDeque<(FenceT, CommandBufferT)>, @@ -64,21 +76,18 @@ pub struct TextureLoader { queue: Arc>, /// The memory allocator being used for textures - tex_allocator: ManuallyDrop, + tex_mempool: Arc>, /// The memory allocator for staging memory - staging_allocator: ManuallyDrop, + staging_mempool: Arc>, /// Allocator for descriptor sets descriptor_allocator: ManuallyDrop, ds_layout: Arc>, - /// Type ID for staging memory - staging_memory_type: MemoryTypeId, - /// From adapter, used for determining alignment - optimal_buffer_copy_pitch_alignment: hal::buffer::Offset, + optimal_buffer_copy_pitch_alignment: u32, /// Configuration for how to find and load textures config: TextureLoadConfig, @@ -88,19 +97,20 @@ pub struct TextureLoader { request_channel: Receiver, /// The channel blocks are returned to. - return_channel: Sender>, + return_channel: Sender>, /// A filler image for descriptors that aren't needed but still need to be written to - blank_image: ManuallyDrop>, -} - -#[derive(Error, Debug)] -pub enum TextureLoaderError { - #[error("Couldn't find a suitable memory type")] - NoMemoryTypes, + blank_image: ManuallyDrop>, } -impl TextureLoader { +impl TextureLoader +where + R: TextureResolver, + TP: MemoryPool, + SP: MemoryPool, + SP::Block: MappableBlock, +{ + /// Keep loading textures until asked to stop. This should be called from a seperate thread. pub fn loop_until_exit(mut self) -> Result { debug!("TextureLoader starting main loop"); let mut res = Ok(false); @@ -123,12 +133,15 @@ impl TextureLoader { _ => unreachable!(), } } + fn main(&mut self) -> Result { + // Get a device lock so we can check fence status let mut device = self .device .write() .map_err(|_| LockPoisoned::Device) .context("Error getting device lock")?; + // Check for blocks that are finished, then send them back let mut i = 0; while i < self.commands_queued.len() { @@ -139,12 +152,21 @@ impl TextureLoader { let (assets, mut staging_bufs, block) = self.commands_queued.remove(i).dissolve(); debug!("Load finished for texture block {:?}", block.id); + // Lock staging memory pool + let mut staging_mempool = self + .staging_mempool + .write() + .map_err(|_| LockPoisoned::MemoryPool)?; + // Destroy staging buffers for buf in staging_bufs.drain(..) { - buf.deactivate(&mut device, &mut self.staging_allocator); + buf.deactivate_device_pool(&mut device, &mut *staging_mempool); } + // Return assets used for loading self.buffers.push_back(assets); + + // Send back our loaded block self.return_channel .send(block) .context("Error returning texture block")?; @@ -153,6 +175,7 @@ impl TextureLoader { } } + // Release device lock drop(device); // Check for messages to start loading blocks @@ -181,97 +204,42 @@ impl TextureLoader { Ok(false) } - pub fn new( - adapter: &Adapter, - device_lock: Arc>, - (family, queue_lock): (QueueFamilyId, Arc>), + /// Create a new loader from the given context. + pub fn new( + context: &mut RenderingContext, ds_layout: Arc>, - (request_channel, return_channel): ( - Receiver, - Sender>, - ), + (request_channel, return_channel): (Receiver, Sender>), config: TextureLoadConfig, ) -> Result { + // Queue family & Lock + let family = context + .queue_negotiator_mut() + .family::() + .ok_or(EnvironmentError::NoSuitableFamilies)?; + let queue_lock = context + .queue_negotiator_mut() + .get_queue::() + .ok_or(EnvironmentError::NoQueues)?; + + // Memory pools + let tex_mempool = context.memory_pool()?.clone(); + let staging_mempool = context.memory_pool()?.clone(); + + // Lock device + let device_lock = context.device().clone(); let mut device = device_lock .write() .map_err(|_| LockPoisoned::Device) .context("Error getting device lock")?; - let device_props = adapter.physical_device.properties(); - - let type_mask = unsafe { - use hal::image::{Kind, Tiling, Usage, ViewCapabilities}; - - // We create an empty image with the same format as used for textures - // this is to get the type_mask required, which will stay the same for - // all colour images of the same tiling. (certain memory flags excluded). - - // Size and alignment don't necessarily stay the same, so we're forced to - // guess at the alignment for our allocator. - - // TODO: Way to tune these options - let img = device - .create_image( - Kind::D2(16, 16, 1, 1), - 1, - Format::Rgba8Srgb, - Tiling::Optimal, - Usage::SAMPLED, - SparseFlags::empty(), - ViewCapabilities::empty(), - ) - .context("Error creating test image to get buffer settings")?; - - let type_mask = device.get_image_requirements(&img).type_mask; - - device.destroy_image(img); - type_mask - }; - - debug!("Using type mask {:?}", type_mask); - - // Tex Allocator - let mut tex_allocator = { - let props = MemProps::DEVICE_LOCAL; - - DynamicAllocator::new( - find_memory_type_id(adapter, type_mask, props) - .ok_or(TextureLoaderError::NoMemoryTypes) - .context("Couldn't create tex memory allocator")?, - props, - DynamicConfig { - block_size_granularity: 4 * 32 * 32, // 32x32 image - max_chunk_size: u64::pow(2, 63), - min_device_allocation: 4 * 32 * 32, - }, - device_props.limits.non_coherent_atom_size as u64, - ) - }; - - let (staging_memory_type, mut staging_allocator) = { - let props = MemProps::CPU_VISIBLE | MemProps::COHERENT; - let t = find_memory_type_id(adapter, u32::MAX, props) - .ok_or(TextureLoaderError::NoMemoryTypes) - .context("Couldn't create staging memory allocator")?; - ( - t, - DynamicAllocator::new( - t, - props, - DynamicConfig { - block_size_granularity: 4 * 32 * 32, // 32x32 image - max_chunk_size: u64::pow(2, 63), - min_device_allocation: 4 * 32 * 32, - }, - device_props.limits.non_coherent_atom_size as u64, - ), - ) - }; + // Physical properties + let device_props = context.physical_device_properties(); + let optimal_buffer_copy_pitch_alignment = + device_props.limits.optimal_buffer_copy_pitch_alignment as u32; // Pool let mut pool = unsafe { use hal::pool::CommandPoolCreateFlags; - device.create_command_pool(family, CommandPoolCreateFlags::RESET_INDIVIDUAL) } .context("Error creating command pool")?; @@ -293,16 +261,13 @@ impl TextureLoader { data }; - let optimal_buffer_copy_pitch_alignment = - device_props.limits.optimal_buffer_copy_pitch_alignment; - + // Blank image (for padding descriptors) let blank_image = unsafe { Self::get_blank_image( &mut device, &mut buffers[0].1, &queue_lock, - (&mut staging_allocator, &mut tex_allocator), - staging_memory_type, + (&staging_mempool, &tex_mempool), optimal_buffer_copy_pitch_alignment, &config, ) @@ -319,11 +284,10 @@ impl TextureLoader { queue: queue_lock, ds_layout, - tex_allocator: ManuallyDrop::new(tex_allocator), - staging_allocator: ManuallyDrop::new(staging_allocator), + tex_mempool, + staging_mempool, descriptor_allocator: ManuallyDrop::new(DescriptorAllocator::new()), - staging_memory_type, optimal_buffer_copy_pitch_alignment, request_channel, @@ -333,7 +297,7 @@ impl TextureLoader { }) } - unsafe fn attempt_queue_load(&mut self, block_ref: usize) -> Result> { + unsafe fn attempt_queue_load(&mut self, block_ref: usize) -> Result> { let mut device = self .device .write() @@ -403,7 +367,7 @@ impl TextureLoader { binding: 0, array_offset: tex_idx % BLOCK_SIZE, descriptors: once(Descriptor::Image( - &*self.blank_image.img_view, + &*self.blank_image.img_view(), Layout::ShaderReadOnlyOptimal, )), }); @@ -411,7 +375,7 @@ impl TextureLoader { set: descriptor_set.raw_mut(), binding: 1, array_offset: tex_idx % BLOCK_SIZE, - descriptors: once(Descriptor::Sampler(&*self.blank_image.sampler)), + descriptors: once(Descriptor::Sampler(&*self.blank_image.sampler())), }); continue; @@ -423,9 +387,8 @@ impl TextureLoader { let (staging_buffer, img) = load_image( &mut device, - &mut self.staging_allocator, - &mut self.tex_allocator, - self.staging_memory_type, + &mut self.staging_mempool, + &mut self.tex_mempool, self.optimal_buffer_copy_pitch_alignment, img_data, &self.config, @@ -438,7 +401,7 @@ impl TextureLoader { binding: 0, array_offset, descriptors: once(Descriptor::Image( - &*img.img_view, + img.img_view(), Layout::ShaderReadOnlyOptimal, )), }); @@ -446,7 +409,7 @@ impl TextureLoader { set: descriptor_set.raw_mut(), binding: 1, array_offset, - descriptors: once(Descriptor::Sampler(&*img.sampler)), + descriptors: once(Descriptor::Sampler(img.sampler())), }); } @@ -462,7 +425,7 @@ impl TextureLoader { imgs.iter().map(|li| Barrier::Image { states: (Access::empty(), Layout::Undefined) ..(Access::TRANSFER_WRITE, Layout::TransferDstOptimal), - target: &*li.img, + target: &*li.img(), families: None, range: SubresourceRange { aspects: Aspects::COLOR, @@ -477,13 +440,13 @@ impl TextureLoader { // Record copy commands for (li, sb) in imgs.iter().zip(staging_bufs.iter()) { buf.copy_buffer_to_image( - &*sb.buf, - &*li.img, + &*sb.buf(), + &*li.img(), Layout::TransferDstOptimal, once(BufferImageCopy { buffer_offset: 0, - buffer_width: (li.row_size / super::PIXEL_SIZE) as u32, - buffer_height: li.height, + buffer_width: (li.row_size() / get_pixel_size(FORMAT)) as u32, + buffer_height: li.height(), image_layers: SubresourceLayers { aspects: Aspects::COLOR, level: 0, @@ -491,8 +454,8 @@ impl TextureLoader { }, image_offset: Offset { x: 0, y: 0, z: 0 }, image_extent: gfx_hal::image::Extent { - width: li.width, - height: li.height, + width: li.unpadded_row_size(), + height: li.height(), depth: 1, }, }), @@ -504,7 +467,7 @@ impl TextureLoader { imgs.iter().map(|li| Barrier::Image { states: (Access::TRANSFER_WRITE, Layout::TransferDstOptimal) ..(Access::empty(), Layout::ShaderReadOnlyOptimal), - target: &*li.img, + target: &*li.img(), families: None, range: RESOURCES, }), @@ -535,11 +498,10 @@ impl TextureLoader { device: &mut DeviceT, buf: &mut CommandBufferT, queue_lock: &Arc>, - (staging_allocator, tex_allocator): (&mut DynamicAllocator, &mut DynamicAllocator), - staging_memory_type: MemoryTypeId, - obcpa: u64, + (staging_mempool, tex_mempool): (&Arc>, &Arc>), + obcpa: u32, config: &TextureLoadConfig, - ) -> Result> { + ) -> Result> { let img_data = RgbaImage::from_pixel(1, 1, Rgba([255, 0, 255, 255])); let height = img_data.height(); @@ -551,9 +513,8 @@ impl TextureLoader { let (staging_buffer, img) = load_image( device, - staging_allocator, - tex_allocator, - staging_memory_type, + staging_mempool, + tex_mempool, obcpa, img_data, config, @@ -567,7 +528,7 @@ impl TextureLoader { once(Barrier::Image { states: (Access::empty(), Layout::Undefined) ..(Access::TRANSFER_WRITE, Layout::TransferDstOptimal), - target: &*img.img, + target: &*img.img(), families: None, range: SubresourceRange { aspects: Aspects::COLOR, @@ -579,8 +540,8 @@ impl TextureLoader { }), ); buf.copy_buffer_to_image( - &*staging_buffer.buf, - &*img.img, + &*staging_buffer.buf(), + &*img.img(), Layout::TransferDstOptimal, once(BufferImageCopy { buffer_offset: 0, @@ -602,7 +563,7 @@ impl TextureLoader { once(Barrier::Image { states: (Access::TRANSFER_WRITE, Layout::TransferDstOptimal) ..(Access::empty(), Layout::ShaderReadOnlyOptimal), - target: &*img.img, + target: &*img.img(), families: None, range: RESOURCES, }), @@ -628,7 +589,10 @@ impl TextureLoader { device.destroy_fence(fence); - staging_buffer.deactivate(device, staging_allocator); + { + let mut staging_mempool = staging_mempool.write().unwrap(); + staging_buffer.deactivate_device_pool(device, &mut *staging_mempool); + } Ok(img) } @@ -658,8 +622,9 @@ impl TextureLoader { device.destroy_fence(assets.0); // Command buffer will be freed when we reset the command pool // Destroy staging buffers + let mut staging_mempool = self.staging_mempool.write().unwrap(); for buf in staging_bufs.drain(..) { - buf.deactivate(&mut device, &mut self.staging_allocator); + buf.deactivate_device_pool(&mut device, &mut staging_mempool); } self.return_channel @@ -674,7 +639,11 @@ impl TextureLoader { } // Destroy blank image - read(&*self.blank_image).deactivate(&mut device, &mut *self.tex_allocator); + { + let mut tex_mempool = self.tex_mempool.write().unwrap(); + read(&*self.blank_image) + .deactivate_with_device_pool(&mut device, &mut *tex_mempool); + } // Destroy fences @@ -690,7 +659,6 @@ impl TextureLoader { debug!("Done deactivating TextureLoader"); TextureLoaderRemains { - tex_allocator: ManuallyDrop::new(read(&*self.tex_allocator)), descriptor_allocator: ManuallyDrop::new(read(&*self.descriptor_allocator)), } } @@ -698,7 +666,6 @@ impl TextureLoader { } pub struct TextureLoaderRemains { - pub tex_allocator: ManuallyDrop, pub descriptor_allocator: ManuallyDrop, } diff --git a/stockton-skeleton/src/texture/mod.rs b/stockton-skeleton/src/texture/mod.rs index aef1b03..10fbbad 100644 --- a/stockton-skeleton/src/texture/mod.rs +++ b/stockton-skeleton/src/texture/mod.rs @@ -6,7 +6,6 @@ mod load; mod loader; mod repo; pub mod resolver; -mod staging_buffer; pub use self::block::TexturesBlock; pub use self::image::LoadableImage; diff --git a/stockton-skeleton/src/texture/repo.rs b/stockton-skeleton/src/texture/repo.rs index 341d355..635eebb 100644 --- a/stockton-skeleton/src/texture/repo.rs +++ b/stockton-skeleton/src/texture/repo.rs @@ -4,14 +4,15 @@ use super::{ loader::{BlockRef, LoaderRequest, TextureLoader, TextureLoaderRemains, NUM_SIMULTANEOUS_CMDS}, resolver::TextureResolver, }; -use crate::error::LockPoisoned; -use crate::queue_negotiator::QueueFamilySelector; use crate::types::*; +use crate::{context::RenderingContext, error::LockPoisoned, mem::MappableBlock}; +use crate::{mem::MemoryPool, queue_negotiator::QueueFamilySelector}; use std::{ array::IntoIter, collections::HashMap, iter::empty, + marker::PhantomData, mem::ManuallyDrop, sync::{ mpsc::{channel, Receiver, Sender}, @@ -21,10 +22,7 @@ use std::{ }; use anyhow::{Context, Result}; -use hal::{ - pso::{DescriptorSetLayoutBinding, DescriptorType, ImageDescriptorType, ShaderStageFlags}, - queue::family::QueueFamilyId, -}; +use hal::pso::{DescriptorSetLayoutBinding, DescriptorType, ImageDescriptorType, ShaderStageFlags}; use log::debug; /// The number of textures in one 'block' @@ -32,26 +30,46 @@ use log::debug; /// Whenever a texture is needed, the whole block its in is loaded. pub const BLOCK_SIZE: usize = 8; -pub struct TextureRepo { +/// An easy way to load [`super::LoadableImage`]s into GPU memory using another thread. +/// This assumes each texture has a numeric id, and will group them into blocks of `[BLOCK_SIZE]`, +/// yielding descriptor sets with that many samplers and images. +/// You only need to supply a [`super::resolver::TextureResolver`] and create one from the main thread. +/// Then, use [`get_ds_layout`] in your graphics pipeline. +/// Make sure to call [`process_responses`] every frame. +/// Then, whenever you draw, use [`attempt_get_descriptor_set`] to see if that texture has finished loading, +/// or `queue_load` to start loading it ASAP. + +pub struct TextureRepo +where + TP: MemoryPool, + SP: MemoryPool, + SP::Block: MappableBlock, +{ joiner: ManuallyDrop>>, ds_layout: Arc>, req_send: Sender, - resp_recv: Receiver>, - blocks: HashMap>>, + resp_recv: Receiver>, + blocks: HashMap>>, + _d: PhantomData<(TP, SP)>, } -impl TextureRepo { - pub fn new( - device_lock: Arc>, - family: QueueFamilyId, - queue: Arc>, - adapter: &Adapter, +impl TextureRepo +where + TP: MemoryPool, + SP: MemoryPool, + SP::Block: MappableBlock, +{ + /// Create a new TextureRepo from the given context. + /// Q should most likely be [`TexLoadQueue`] + pub fn new( + context: &mut RenderingContext, config: TextureLoadConfig, ) -> Result { // Create Channels let (req_send, req_recv) = channel(); let (resp_send, resp_recv) = channel(); - let device = device_lock + let device = context + .device() .write() .map_err(|_| LockPoisoned::Device) .context("Error getting device lock")?; @@ -91,10 +109,8 @@ impl TextureRepo { drop(device); let joiner = { - let loader = TextureLoader::new( - adapter, - device_lock.clone(), - (family, queue), + let loader = >::new::( + context, ds_lock.clone(), (req_recv, resp_send), config, @@ -109,9 +125,12 @@ impl TextureRepo { blocks: HashMap::new(), req_send, resp_recv, + _d: PhantomData, }) } + /// Get the descriptor layout used for each texture descriptor + /// This can be used when creating graphics pipelines. pub fn get_ds_layout(&self) -> Result> { self.ds_layout .read() @@ -119,6 +138,7 @@ impl TextureRepo { .context("Error locking descriptor set layout") } + /// Ask for the given block to be loaded, if it's not already. pub fn queue_load(&mut self, block_id: BlockRef) -> Result<()> { if self.blocks.contains_key(&block_id) { return Ok(()); @@ -127,6 +147,7 @@ impl TextureRepo { self.force_queue_load(block_id) } + /// Ask for the given block to be loaded, even if it already has been. pub fn force_queue_load(&mut self, block_id: BlockRef) -> Result<()> { self.req_send .send(LoaderRequest::Load(block_id)) @@ -137,12 +158,14 @@ impl TextureRepo { Ok(()) } + /// Get the descriptor set for the given block, if it's loaded. pub fn attempt_get_descriptor_set(&mut self, block_id: BlockRef) -> Option<&DescriptorSetT> { self.blocks .get(&block_id) .and_then(|opt| opt.as_ref().map(|z| z.descriptor_set.raw())) } + /// Process any textures that just finished loading. This should be called every frame. pub fn process_responses(&mut self) { let resp_iter: Vec<_> = self.resp_recv.try_iter().collect(); for resp in resp_iter { @@ -151,7 +174,8 @@ impl TextureRepo { } } - pub fn deactivate(mut self, device_lock: &Arc>) { + /// Destroy all vulkan objects. Should be called before dropping. + pub fn deactivate(mut self, context: &mut RenderingContext) { unsafe { use std::ptr::read; @@ -162,22 +186,27 @@ impl TextureRepo { // Process any ones that just got done loading self.process_responses(); + let mut tex_allocator = context + .existing_memory_pool::() + .unwrap() + .write() + .unwrap(); + // Only now can we lock device without deadlocking - let mut device = device_lock.write().unwrap(); + let mut device = context.device().write().unwrap(); // Return all the texture memory and descriptors. for (_, v) in self.blocks.drain() { if let Some(block) = v { block.deactivate( &mut device, - &mut *remains.tex_allocator, + &mut *tex_allocator, &mut remains.descriptor_allocator, ); } } - // Dispose of both allocators - read(&*remains.tex_allocator).dispose(); + // Dispose of the descriptor allocator read(&*remains.descriptor_allocator).dispose(&device); // Deactivate DS Layout @@ -190,6 +219,7 @@ impl TextureRepo { } } +/// The queue to use when loading textures pub struct TexLoadQueue; impl QueueFamilySelector for TexLoadQueue { diff --git a/stockton-skeleton/src/texture/staging_buffer.rs b/stockton-skeleton/src/texture/staging_buffer.rs deleted file mode 100644 index 8d2ae17..0000000 --- a/stockton-skeleton/src/texture/staging_buffer.rs +++ /dev/null @@ -1,59 +0,0 @@ -#![allow(mutable_transmutes)] -use crate::types::*; - -use std::mem::ManuallyDrop; - -use anyhow::{Context, Result}; -use hal::{device::MapError, memory::SparseFlags, MemoryTypeId}; -use rendy_memory::{Allocator, Block}; - -pub struct StagingBuffer { - pub buf: ManuallyDrop, - pub mem: ManuallyDrop, -} - -impl StagingBuffer { - const USAGE: hal::buffer::Usage = hal::buffer::Usage::TRANSFER_SRC; - - pub fn new( - device: &mut DeviceT, - alloc: &mut DynamicAllocator, - size: u64, - _memory_type_id: MemoryTypeId, - ) -> Result { - let mut buffer = unsafe { device.create_buffer(size, Self::USAGE, SparseFlags::empty()) } - .context("Error creating buffer")?; - - let requirements = unsafe { device.get_buffer_requirements(&buffer) }; - - let (memory, _) = alloc - .alloc(device, requirements.size, requirements.alignment) - .context("Error allocating staging memory")?; - - unsafe { device.bind_buffer_memory(memory.memory(), 0, &mut buffer) } - .context("Error binding staging memory to buffer")?; - - Ok(StagingBuffer { - buf: ManuallyDrop::new(buffer), - mem: ManuallyDrop::new(memory), - }) - } - - pub unsafe fn map_memory(&mut self, device: &mut DeviceT) -> Result<*mut u8, MapError> { - let range = 0..(self.mem.range().end - self.mem.range().start); - Ok(self.mem.map(device, range)?.ptr().as_mut()) - } - pub unsafe fn unmap_memory(&mut self, device: &mut DeviceT) { - self.mem.unmap(device); - } - - pub fn deactivate(self, device: &mut DeviceT, alloc: &mut DynamicAllocator) { - unsafe { - use std::ptr::read; - // Destroy buffer - device.destroy_buffer(read(&*self.buf)); - // Free memory - alloc.free(device, read(&*self.mem)); - } - } -} diff --git a/stockton-skeleton/src/utils.rs b/stockton-skeleton/src/utils.rs index 152ba10..253ad7f 100644 --- a/stockton-skeleton/src/utils.rs +++ b/stockton-skeleton/src/utils.rs @@ -1,5 +1,5 @@ use crate::types::*; -use hal::{memory::Properties as MemProperties, MemoryTypeId}; +use hal::{format::Format, memory::Properties as MemProperties, MemoryTypeId}; pub fn find_memory_type_id( adapter: &Adapter, @@ -17,3 +17,7 @@ pub fn find_memory_type_id( }) .map(|(id, _)| MemoryTypeId(id)) } + +pub fn get_pixel_size(f: Format) -> u32 { + f.surface_desc().bits as u32 / 8 +} -- cgit v1.2.3