MeshPool redux
This commit is contained in:
parent
fb525ec3d1
commit
2ac5da0164
|
@ -0,0 +1,391 @@
|
||||||
|
use crate::staging::*;
|
||||||
|
use slab::Slab;
|
||||||
|
use smallvec::SmallVec;
|
||||||
|
use std::any::TypeId;
|
||||||
|
use std::collections::HashMap;
|
||||||
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
/// An error that can be returned when allocating a mesh.
|
||||||
|
pub enum PoolError {
|
||||||
|
TooBig,
|
||||||
|
NoMoreRoom,
|
||||||
|
InvalidIndex,
|
||||||
|
AttrTaken,
|
||||||
|
AttrUnregistered,
|
||||||
|
MismatchedId,
|
||||||
|
MismatchedLayout,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An identifier for a mesh attribute.
|
||||||
|
#[repr(transparent)]
|
||||||
|
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
|
||||||
|
pub struct AttrId(usize);
|
||||||
|
|
||||||
|
/// A description of an attribute's layout in memory.
|
||||||
|
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
|
||||||
|
pub struct AttrLayout {
|
||||||
|
/// The size (in bytes) of this attribute.
|
||||||
|
pub size: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Information about an [Attribute] registered in [AttrStore].
|
||||||
|
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
|
||||||
|
pub struct AttrInfo {
|
||||||
|
pub layout: AttrLayout,
|
||||||
|
pub default_pool_size: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The data single mesh attribute.
|
||||||
|
pub struct AttrBuffer {
|
||||||
|
pub id: AttrId,
|
||||||
|
pub count: usize,
|
||||||
|
pub data: Vec<u8>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A compile-time attribute data type.
|
||||||
|
pub trait Attribute: Sized {
|
||||||
|
/// The memory layout of this data.
|
||||||
|
fn get_layout() -> AttrLayout {
|
||||||
|
AttrLayout {
|
||||||
|
size: std::mem::size_of::<Self>(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The default size for new pools of this attribute.
|
||||||
|
///
|
||||||
|
/// Defaults to 1024 * 1024. (Around one million.)
|
||||||
|
fn get_default_pool_size() -> usize {
|
||||||
|
1024 * 1024
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A store of [AttrIds][AttrId].
|
||||||
|
pub struct AttrStore {
|
||||||
|
attributes: Slab<AttrInfo>,
|
||||||
|
types: HashMap<TypeId, AttrId>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AttrStore {
|
||||||
|
pub fn new() -> Arc<Self> {
|
||||||
|
Arc::new(Self {
|
||||||
|
attributes: Default::default(),
|
||||||
|
types: Default::default(),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Dynamically creates a new [AttrId].
|
||||||
|
pub fn add(&mut self, info: AttrInfo) -> AttrId {
|
||||||
|
let index = self.attributes.insert(info);
|
||||||
|
AttrId(index)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Gets the [AttrId] for a type implementing [Attribute].
|
||||||
|
///
|
||||||
|
/// Creates a new [AttrId] for unrecognized types, otherwise reuses an
|
||||||
|
/// existing [AttrId].
|
||||||
|
pub fn get_type<T: 'static + Attribute>(&mut self) -> AttrId {
|
||||||
|
let type_id = TypeId::of::<T>();
|
||||||
|
if let Some(id) = self.types.get(&type_id) {
|
||||||
|
*id
|
||||||
|
} else {
|
||||||
|
let layout = T::get_layout();
|
||||||
|
let default_pool_size = T::get_default_pool_size();
|
||||||
|
let info = AttrInfo {
|
||||||
|
layout,
|
||||||
|
default_pool_size,
|
||||||
|
};
|
||||||
|
let id = self.add(info);
|
||||||
|
self.types.insert(type_id, id);
|
||||||
|
id
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Gets the [AttrInfo] for an [AttrId].
|
||||||
|
pub fn get_info(&self, id: &AttrId) -> Option<&AttrInfo> {
|
||||||
|
self.attributes.get(id.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Attribute pool allocation location.
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct AttrAllocKey {
|
||||||
|
/// The target attribute.
|
||||||
|
pub attr: AttrId,
|
||||||
|
|
||||||
|
/// The index of the attribute pool.
|
||||||
|
pub pool: usize,
|
||||||
|
|
||||||
|
/// The allocation within the attribute pool.
|
||||||
|
pub alloc: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Info about an array of attributes that has been allocated in an [AttrPool].
|
||||||
|
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
|
||||||
|
pub struct AttrAlloc {
|
||||||
|
offset: usize,
|
||||||
|
count: usize,
|
||||||
|
offset_bytes: usize,
|
||||||
|
count_bytes: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An unused space range in an [AttrPool].
|
||||||
|
pub struct FreeSpace {
|
||||||
|
offset: usize,
|
||||||
|
count: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A single GPU buffer containing linear arrays of attributes.
|
||||||
|
pub struct AttrPool {
|
||||||
|
id: AttrId,
|
||||||
|
pool_id: usize,
|
||||||
|
layout: AttrLayout,
|
||||||
|
size: usize,
|
||||||
|
allocs: Slab<AttrAlloc>,
|
||||||
|
free_space: Vec<FreeSpace>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AttrPool {
|
||||||
|
pub fn new(id: AttrId, pool_id: usize, info: AttrInfo) -> Self {
|
||||||
|
let layout = info.layout;
|
||||||
|
let size = info.default_pool_size;
|
||||||
|
|
||||||
|
Self {
|
||||||
|
id,
|
||||||
|
pool_id,
|
||||||
|
layout,
|
||||||
|
size,
|
||||||
|
free_space: vec![FreeSpace {
|
||||||
|
offset: 0,
|
||||||
|
count: size,
|
||||||
|
}],
|
||||||
|
allocs: Default::default(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Loads an [AttrBuffer].
|
||||||
|
///
|
||||||
|
/// Returns the new [AttrAllocKey].
|
||||||
|
pub fn load(&mut self, buf: &AttrBuffer) -> Result<AttrAllocKey, PoolError> {
|
||||||
|
let best_index = self.can_load(buf)?;
|
||||||
|
self.alloc_at(best_index, buf.count)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Allocates an array of attributes.
|
||||||
|
///
|
||||||
|
/// Returns the new [AttrAllocKey].
|
||||||
|
pub fn alloc(&mut self, count: usize) -> Result<AttrAllocKey, PoolError> {
|
||||||
|
let best_index = self.can_alloc(count)?;
|
||||||
|
self.alloc_at(best_index, count)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Tests if an [AttrBuffer] can be loaded.
|
||||||
|
///
|
||||||
|
/// Returns the result of [Self::best_fit].
|
||||||
|
pub fn can_load(&self, buf: &AttrBuffer) -> Result<usize, PoolError> {
|
||||||
|
if buf.id != self.id {
|
||||||
|
Err(PoolError::MismatchedId)
|
||||||
|
} else if buf.count * self.layout.size != buf.data.len() {
|
||||||
|
Err(PoolError::MismatchedLayout)
|
||||||
|
} else {
|
||||||
|
self.can_alloc(buf.count)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Tests if an array of attributes can be allocated.
|
||||||
|
///
|
||||||
|
/// Returns the result of [Self::best_fit].
|
||||||
|
pub fn can_alloc(&self, count: usize) -> Result<usize, PoolError> {
|
||||||
|
if count > self.size {
|
||||||
|
Err(PoolError::TooBig)
|
||||||
|
} else if let Some(best_index) = self.best_fit(count) {
|
||||||
|
Ok(best_index)
|
||||||
|
} else {
|
||||||
|
Err(PoolError::NoMoreRoom)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Finds the index of the best-fit free space for an array of attributes.
|
||||||
|
///
|
||||||
|
/// TODO: use a binary tree to find best-fit free space in logarithmic time
|
||||||
|
fn best_fit(&self, count: usize) -> Option<usize> {
|
||||||
|
let mut best_index = None;
|
||||||
|
let mut best_count = usize::MAX;
|
||||||
|
for (index, space) in self.free_space.iter().enumerate() {
|
||||||
|
if space.count >= count && space.count < best_count {
|
||||||
|
best_index = Some(index);
|
||||||
|
best_count = space.count;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
best_index
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Allocates an array of attribute at a specific free space index.
|
||||||
|
///
|
||||||
|
/// Returns the new [AttrAllocKey].
|
||||||
|
fn alloc_at(
|
||||||
|
&mut self,
|
||||||
|
index: usize,
|
||||||
|
count: usize,
|
||||||
|
) -> Result<AttrAllocKey, PoolError> {
|
||||||
|
let free_space = match self.free_space.get_mut(index) {
|
||||||
|
Some(index) => index,
|
||||||
|
None => return Err(PoolError::InvalidIndex),
|
||||||
|
};
|
||||||
|
|
||||||
|
let offset = free_space.offset;
|
||||||
|
|
||||||
|
let alloc = AttrAlloc {
|
||||||
|
offset,
|
||||||
|
count,
|
||||||
|
offset_bytes: offset * self.layout.size,
|
||||||
|
count_bytes: count * self.layout.size,
|
||||||
|
};
|
||||||
|
|
||||||
|
let index = self.allocs.insert(alloc);
|
||||||
|
|
||||||
|
let key = AttrAllocKey {
|
||||||
|
attr: self.id,
|
||||||
|
pool: self.pool_id,
|
||||||
|
alloc: index,
|
||||||
|
};
|
||||||
|
|
||||||
|
use std::cmp::Ordering;
|
||||||
|
match free_space.count.cmp(&count) {
|
||||||
|
Ordering::Less => {
|
||||||
|
return Err(PoolError::TooBig);
|
||||||
|
}
|
||||||
|
Ordering::Equal => {
|
||||||
|
self.free_space.remove(index);
|
||||||
|
}
|
||||||
|
Ordering::Greater => {
|
||||||
|
free_space.count -= count;
|
||||||
|
free_space.offset += count;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(key)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Frees an allocation (by key) from the pool.
|
||||||
|
pub fn free(&mut self, key: usize) -> Result<(), PoolError> {
|
||||||
|
let alloc = self.allocs.try_remove(key).ok_or(PoolError::InvalidIndex)?;
|
||||||
|
|
||||||
|
let free_space = FreeSpace {
|
||||||
|
offset: alloc.offset,
|
||||||
|
count: alloc.count,
|
||||||
|
};
|
||||||
|
|
||||||
|
// TODO merge free spaces
|
||||||
|
self.free_space.push(free_space);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The number of attributes a mesh can have before they're moved to the heap.
|
||||||
|
pub const MAX_MESH_INLINE_ATTRIBUTES: usize = 16;
|
||||||
|
|
||||||
|
/// A mesh and all of its attributes.
|
||||||
|
pub struct MeshBuffer {
|
||||||
|
pub attributes: SmallVec<[AttrBuffer; MAX_MESH_INLINE_ATTRIBUTES]>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An allocated mesh.
|
||||||
|
pub struct MeshAlloc {
|
||||||
|
pub attributes: SmallVec<[AttrAllocKey; MAX_MESH_INLINE_ATTRIBUTES]>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A handle to an allocated mesh.
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct MeshHandle(usize);
|
||||||
|
|
||||||
|
impl HasMeshHandle for MeshHandle {
|
||||||
|
fn get_mesh_handle(&self) -> &Self {
|
||||||
|
self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A trait for structs containing [MeshHandles][MeshHandle] that are not
|
||||||
|
/// themselves handles. Used for iteration.
|
||||||
|
pub trait HasMeshHandle {
|
||||||
|
fn get_mesh_handle(&self) -> &MeshHandle;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A mesh data pool.
|
||||||
|
pub struct MeshPool {
|
||||||
|
device: Arc<wgpu::Device>,
|
||||||
|
staging: StagingPool<AttrAllocKey>,
|
||||||
|
attr_store: Arc<AttrStore>,
|
||||||
|
allocs: Slab<MeshAlloc>,
|
||||||
|
pools: HashMap<AttrId, Vec<AttrPool>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl MeshPool {
|
||||||
|
pub fn new(device: Arc<wgpu::Device>, attr_store: Arc<AttrStore>) -> Arc<Self> {
|
||||||
|
Arc::new(Self {
|
||||||
|
device: device.clone(),
|
||||||
|
staging: StagingPool::new(device, 1024 * 1024),
|
||||||
|
attr_store,
|
||||||
|
allocs: Default::default(),
|
||||||
|
pools: Default::default(),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Loads a [MeshBuffer].
|
||||||
|
pub fn load(&mut self, buf: MeshBuffer) -> Result<MeshHandle, PoolError> {
|
||||||
|
let mut attrs = HashMap::new();
|
||||||
|
|
||||||
|
for attr in buf.attributes.into_iter() {
|
||||||
|
if let Some(_) = attrs.insert(attr.id, attr) {
|
||||||
|
// TODO: support for loading duplicate attribute IDs
|
||||||
|
return Err(PoolError::AttrTaken);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut attr_allocs = SmallVec::new();
|
||||||
|
let mut copies = Vec::new();
|
||||||
|
for (id, buf) in attrs.drain() {
|
||||||
|
let pools = match self.pools.get_mut(&id) {
|
||||||
|
Some(pools) => pools,
|
||||||
|
None => {
|
||||||
|
let info = match self.attr_store.get_info(&id) {
|
||||||
|
Some(info) => info,
|
||||||
|
None => return Err(PoolError::AttrUnregistered),
|
||||||
|
};
|
||||||
|
|
||||||
|
let pool = AttrPool::new(id, 0, *info);
|
||||||
|
self.pools.insert(id, vec![pool]);
|
||||||
|
self.pools.get_mut(&id).unwrap()
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
for pool in pools.iter_mut() {
|
||||||
|
match pool.load(&buf) {
|
||||||
|
Ok(alloc) => {
|
||||||
|
let copy = CopyBuffer {
|
||||||
|
target: alloc.clone(),
|
||||||
|
offset: 0,
|
||||||
|
data: buf.data,
|
||||||
|
};
|
||||||
|
|
||||||
|
attr_allocs.push(alloc);
|
||||||
|
copies.push(copy);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
Err(PoolError::NoMoreRoom) => {}
|
||||||
|
Err(e) => return Err(e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
self.staging.queue_copies(copies);
|
||||||
|
|
||||||
|
let alloc = MeshAlloc {
|
||||||
|
attributes: attr_allocs,
|
||||||
|
};
|
||||||
|
let key = self.allocs.insert(alloc);
|
||||||
|
let handle = MeshHandle(key);
|
||||||
|
Ok(handle)
|
||||||
|
}
|
||||||
|
}
|
243
src/mesh/attr.rs
243
src/mesh/attr.rs
|
@ -1,243 +0,0 @@
|
||||||
//! Mesh storage pooling for a single attribute.
|
|
||||||
//!
|
|
||||||
//! Attribute pools have a fixed size, and once created cannot be expanded to
|
|
||||||
//! fit more data.
|
|
||||||
|
|
||||||
use super::*;
|
|
||||||
use std::any::TypeId;
|
|
||||||
use std::collections::HashMap;
|
|
||||||
|
|
||||||
/// An externally-defined identifier for a mesh attribute.
|
|
||||||
#[repr(transparent)]
|
|
||||||
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
|
|
||||||
pub struct AttrId(pub usize);
|
|
||||||
|
|
||||||
/// A description of a attribute's layout in memory.
|
|
||||||
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
|
|
||||||
pub struct AttrLayout {
|
|
||||||
/// The size (in bytes) of this attribute.
|
|
||||||
pub size: usize,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Information about an [Attribute] registered in [AttrStore].
|
|
||||||
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
|
|
||||||
pub struct AttrInfo {
|
|
||||||
pub layout: AttrLayout,
|
|
||||||
pub default_pool_size: usize,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A compile-time attribute data type.
|
|
||||||
pub trait Attribute: Sized {
|
|
||||||
/// The memory layout of this data.
|
|
||||||
fn get_layout() -> AttrLayout {
|
|
||||||
AttrLayout {
|
|
||||||
size: std::mem::size_of::<Self>(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The default size for new pools of this attribute.
|
|
||||||
///
|
|
||||||
/// Defaults to 1024 * 1024. (Around one million.)
|
|
||||||
fn get_default_pool_size() -> usize {
|
|
||||||
1024 * 1024
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A store of [AttrIds][AttrId].
|
|
||||||
pub struct AttrStore {
|
|
||||||
attributes: Slab<AttrInfo>,
|
|
||||||
types: HashMap<TypeId, AttrId>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl AttrStore {
|
|
||||||
pub fn new() -> Self {
|
|
||||||
Self {
|
|
||||||
attributes: Default::default(),
|
|
||||||
types: Default::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Dynamically creates a new [AttrId].
|
|
||||||
pub fn add(&mut self, info: AttrInfo) -> AttrId {
|
|
||||||
let index = self.attributes.insert(info);
|
|
||||||
AttrId(index)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Gets the [AttrId] for a type implementing [Attribute].
|
|
||||||
///
|
|
||||||
/// Creates a new [AttrId] for unrecognized types, otherwise reuses an
|
|
||||||
/// existing [AttrId].
|
|
||||||
pub fn get_type<T: 'static + Attribute>(&mut self) -> AttrId {
|
|
||||||
let type_id = TypeId::of::<T>();
|
|
||||||
if let Some(id) = self.types.get(&type_id) {
|
|
||||||
*id
|
|
||||||
} else {
|
|
||||||
let layout = T::get_layout();
|
|
||||||
let default_pool_size = T::get_default_pool_size();
|
|
||||||
let info = AttrInfo {
|
|
||||||
layout,
|
|
||||||
default_pool_size,
|
|
||||||
};
|
|
||||||
let id = self.add(info);
|
|
||||||
self.types.insert(type_id, id);
|
|
||||||
id
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Gets the [AttrInfo] for an [AttrId].
|
|
||||||
pub fn get_info(&self, id: &AttrId) -> Option<&AttrInfo> {
|
|
||||||
self.attributes.get(id.0)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// An attribute buffer that has been allocated in an [AttrPool].
|
|
||||||
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
|
|
||||||
pub struct AttrAlloc {
|
|
||||||
offset: usize,
|
|
||||||
count: usize,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// An unused space range in an [AttrPool].
|
|
||||||
pub struct FreeSpace {
|
|
||||||
offset: usize,
|
|
||||||
count: usize,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A single GPU buffer containing linear arrays of attributes.
|
|
||||||
pub struct AttrPool {
|
|
||||||
group: usize,
|
|
||||||
id: AttrId,
|
|
||||||
layout: AttrLayout,
|
|
||||||
size: usize,
|
|
||||||
allocs: Slab<AttrAlloc>,
|
|
||||||
free_space: Vec<FreeSpace>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl AttrPool {
|
|
||||||
pub fn new(group: usize, id: AttrId, info: AttrInfo) -> Result<Self, PoolError> {
|
|
||||||
let layout = info.layout;
|
|
||||||
let size = info.default_pool_size;
|
|
||||||
|
|
||||||
Ok(Self {
|
|
||||||
group,
|
|
||||||
id,
|
|
||||||
layout,
|
|
||||||
size,
|
|
||||||
free_space: vec![FreeSpace {
|
|
||||||
offset: 0,
|
|
||||||
count: size,
|
|
||||||
}],
|
|
||||||
allocs: Default::default(),
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests if attributes can be allocated.
|
|
||||||
///
|
|
||||||
/// Returns the result of [Self::best_fit].
|
|
||||||
pub fn can_alloc(&self, count: usize) -> Result<usize, PoolError> {
|
|
||||||
if count > self.size {
|
|
||||||
Err(PoolError::TooBig)
|
|
||||||
} else if let Some(best_index) = self.best_fit(count) {
|
|
||||||
Ok(best_index)
|
|
||||||
} else {
|
|
||||||
Err(PoolError::NoMoreRoom)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests if an [AttrBuffer] can be loaded.
|
|
||||||
///
|
|
||||||
/// Returns the result of [Self::best_fit].
|
|
||||||
pub fn can_load(&self, buf: &AttrBuffer) -> Result<usize, PoolError> {
|
|
||||||
if buf.id != self.id {
|
|
||||||
Err(PoolError::MismatchedId)
|
|
||||||
} else if buf.layout != self.layout {
|
|
||||||
Err(PoolError::MismatchedLayout)
|
|
||||||
} else {
|
|
||||||
self.can_alloc(buf.count)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Finds the index of the best-fit free space for an array of attributes.
|
|
||||||
///
|
|
||||||
/// TODO: use a binary tree to find best-fit free space in logarithmic time
|
|
||||||
pub fn best_fit(&self, count: usize) -> Option<usize> {
|
|
||||||
let mut best_index = None;
|
|
||||||
let mut best_count = usize::MAX;
|
|
||||||
for (index, space) in self.free_space.iter().enumerate() {
|
|
||||||
if space.count >= count && space.count < best_count {
|
|
||||||
best_index = Some(index);
|
|
||||||
best_count = space.count;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
best_index
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Allocates room for attributes at a specific free space index.
|
|
||||||
///
|
|
||||||
/// Returns the new [AttrAlloc] and its key.
|
|
||||||
pub fn alloc_at(
|
|
||||||
&mut self,
|
|
||||||
index: usize,
|
|
||||||
count: usize,
|
|
||||||
) -> Result<(AttrAlloc, usize), PoolError> {
|
|
||||||
let free_space = match self.free_space.get_mut(index) {
|
|
||||||
Some(index) => index,
|
|
||||||
None => return Err(PoolError::InvalidIndex),
|
|
||||||
};
|
|
||||||
|
|
||||||
let alloc = AttrAlloc {
|
|
||||||
offset: free_space.offset,
|
|
||||||
count,
|
|
||||||
};
|
|
||||||
|
|
||||||
let key = self.allocs.insert(alloc);
|
|
||||||
|
|
||||||
use std::cmp::Ordering;
|
|
||||||
match free_space.count.cmp(&count) {
|
|
||||||
Ordering::Less => {
|
|
||||||
return Err(PoolError::TooBig);
|
|
||||||
}
|
|
||||||
Ordering::Equal => {
|
|
||||||
self.free_space.remove(index);
|
|
||||||
}
|
|
||||||
Ordering::Greater => {
|
|
||||||
free_space.count -= count;
|
|
||||||
free_space.offset += count;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok((alloc, key))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Allocates room for attributes.
|
|
||||||
///
|
|
||||||
/// Returns the new [AttrAlloc] and its key.
|
|
||||||
pub fn alloc(&mut self, count: usize) -> Result<(AttrAlloc, usize), PoolError> {
|
|
||||||
let best_index = self.can_alloc(count)?;
|
|
||||||
self.alloc_at(best_index, count)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Loads an [AttrBuffer].
|
|
||||||
///
|
|
||||||
/// Returns the key for the allocation, as well as [CopyInfo] that can be
|
|
||||||
/// queued into a [StagingPool].
|
|
||||||
pub fn load(&mut self, buf: &AttrBuffer) -> Result<(usize, CopyInfo), PoolError> {
|
|
||||||
let best_index = self.can_load(buf)?;
|
|
||||||
let (alloc, key) = self.alloc_at(best_index, buf.count)?;
|
|
||||||
|
|
||||||
let copy = CopyInfo {
|
|
||||||
group: self.group,
|
|
||||||
target: self.id,
|
|
||||||
offset: alloc.offset * self.layout.size,
|
|
||||||
size: alloc.count * self.layout.size,
|
|
||||||
};
|
|
||||||
|
|
||||||
Ok((key, copy))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Frees an allocation (by key) from the pool.
|
|
||||||
pub fn free(&mut self, alloc: usize) -> Result<(), PoolError> {
|
|
||||||
todo!()
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,92 +0,0 @@
|
||||||
//! Fixed-room pooling of mesh data.
|
|
||||||
|
|
||||||
use super::*;
|
|
||||||
use std::sync::Arc;
|
|
||||||
|
|
||||||
/// A mesh that has been allocated in a [MeshGroup].
|
|
||||||
pub struct MeshAlloc {
|
|
||||||
pub attributes: SmallVec<[(usize, AttrId); MAX_MESH_INLINE_ATTRIBUTES]>,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A set of GPU-side vertex attribute pools and index pools.
|
|
||||||
pub struct MeshGroup {
|
|
||||||
id: usize,
|
|
||||||
attr_store: Arc<AttrStore>,
|
|
||||||
pools: HashMap<AttrId, AttrPool>,
|
|
||||||
meshes: Slab<MeshAlloc>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl MeshGroup {
|
|
||||||
pub fn new(id: usize, attr_store: Arc<AttrStore>) -> Self {
|
|
||||||
Self {
|
|
||||||
id,
|
|
||||||
attr_store,
|
|
||||||
pools: Default::default(),
|
|
||||||
meshes: Default::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Checks to see if a mesh can be loaded within this group.
|
|
||||||
pub fn can_load(&self, buf: &MeshBuffer) -> Result<(), PoolError> {
|
|
||||||
for attr in buf.attributes.iter() {
|
|
||||||
match self.pools.get(&attr.id) {
|
|
||||||
None => {
|
|
||||||
match self.attr_store.get_info(&attr.id) {
|
|
||||||
Some(_) => {} // new pools of valid attrs can be made
|
|
||||||
None => return Err(PoolError::AttrUnregistered),
|
|
||||||
};
|
|
||||||
}
|
|
||||||
Some(pool) => {
|
|
||||||
pool.can_load(attr)?;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tries to load a [MeshBuffer] into this pool. Returns a [MeshHandle].
|
|
||||||
pub fn load(&mut self, buf: &MeshBuffer) -> Result<(MeshHandle, Vec<CopyInfo>), PoolError> {
|
|
||||||
self.can_load(&buf)?;
|
|
||||||
|
|
||||||
let mut allocs = SmallVec::with_capacity(buf.attributes.len());
|
|
||||||
let mut copies = Vec::new();
|
|
||||||
|
|
||||||
for attr in buf.attributes.iter() {
|
|
||||||
let id = &attr.id;
|
|
||||||
let pool = match self.pools.get_mut(id) {
|
|
||||||
Some(pool) => pool,
|
|
||||||
None => {
|
|
||||||
let info = match self.attr_store.get_info(id) {
|
|
||||||
Some(info) => *info,
|
|
||||||
None => return Err(PoolError::AttrUnregistered),
|
|
||||||
};
|
|
||||||
|
|
||||||
let new_pool = AttrPool::new(self.id, *id, info)?;
|
|
||||||
self.pools.insert(*id, new_pool);
|
|
||||||
self.pools.get_mut(id).unwrap()
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
let (alloc, copy) = pool.load(attr)?;
|
|
||||||
allocs.push((alloc, attr.id));
|
|
||||||
copies.push(copy);
|
|
||||||
}
|
|
||||||
|
|
||||||
let mesh = MeshAlloc { attributes: allocs };
|
|
||||||
let sub = self.meshes.insert(mesh);
|
|
||||||
let group = self.id;
|
|
||||||
let handle = MeshHandle { group, sub };
|
|
||||||
|
|
||||||
Ok((handle, copies))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Gets a [MeshHandle's][MeshHandle] [MeshAlloc].
|
|
||||||
pub fn get_alloc(&self, handle: &MeshHandle) -> Option<&MeshAlloc> {
|
|
||||||
if handle.group != self.id {
|
|
||||||
None
|
|
||||||
} else {
|
|
||||||
self.meshes.get(handle.sub)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
178
src/mesh/mod.rs
178
src/mesh/mod.rs
|
@ -1,178 +0,0 @@
|
||||||
//! Dynamic mesh data storage.
|
|
||||||
//!
|
|
||||||
//! Meshes are based on ECS-like archetypes. Each pool contains a set of mesh
|
|
||||||
//! "attributes," which can be either vertex attributes, indices of different
|
|
||||||
//! formats (u8, u16, u32), or in the future, fixed-size mesh chunklets too.
|
|
||||||
//! The mesh pool itself is agnostic to specific rendering implementation. It
|
|
||||||
//! has no implicit knowledge of what a vertex position, normal, or texture
|
|
||||||
//! coordinate is, or even what an index is.
|
|
||||||
//!
|
|
||||||
//! Multiple attributes can have the same layout. For example, a rudimentary
|
|
||||||
//! mesh format might use three 32-bit floating point values (`[f32; 3]`) for
|
|
||||||
//! both vertex position and vertex normals. In this case, positions and normals
|
|
||||||
//! would have different [AttrIds][AttrId] to distuingish them, and must each be
|
|
||||||
//! registered to the pool. Once an attribute is registered in a pool instance,
|
|
||||||
//! it cannot be unregistered, although the mesh pool may free GPU buffers for
|
|
||||||
//! unused attribute pools.
|
|
||||||
//!
|
|
||||||
//! Meshes are pooled by [groups][MeshGroup], so all mesh data in a group
|
|
||||||
//! shares the same memory. This allows the rendering pipeline to operate on as
|
|
||||||
//! much mesh data simultaneously as possible without rebinding buffers,
|
|
||||||
//! enabling some highly-efficient rendering techniques like bindless forward
|
|
||||||
//! rendering, bindless vertex skinning, and mesh shading.
|
|
||||||
//!
|
|
||||||
//! However, because a mesh groups' underlying buffers are so large, they cannot
|
|
||||||
//! be resized without copying all of the mesh data within to a new allocation,
|
|
||||||
//! putting a lot of pressure on the GPU's memory bus and causing massive lag
|
|
||||||
//! spikes. Instead, an entirely new group must be created to store more mesh
|
|
||||||
//! data. In practice, new groups will not be created often, again due to the
|
|
||||||
//! large size of their underlying buffers.
|
|
||||||
//!
|
|
||||||
//! When a mesh is loaded, the pool is searched for a group that has spare room
|
|
||||||
//! for all of the mesh's attributes. If one is found, the pool copies the mesh's
|
|
||||||
//! attribute data into the pool's internal staging buffer, which is later
|
|
||||||
//! copied by the GPU into the corresponding attribute pools in the selected
|
|
||||||
//! group. If no group has enough free space to store all of the attributes, a
|
|
||||||
//! new group is created.
|
|
||||||
//!
|
|
||||||
//! Staging buffers are fixed-size, so when a large amount of mesh data is loaded
|
|
||||||
//! at once and the pool can't fit it all into an available staging buffer, the
|
|
||||||
//! memory is instead copied to a CPU-side spillover buffer, and GPU transfer is
|
|
||||||
//! deferred to a future staging pass. Because of this, meshes are not guaranteed
|
|
||||||
//! to be available for drawing on the frame that they are loaded.
|
|
||||||
//!
|
|
||||||
//! TODO: mesh coherency
|
|
||||||
//! TODO: make spillover buffers GPU-transferrable on iGPUs
|
|
||||||
|
|
||||||
use slab::Slab;
|
|
||||||
use smallvec::SmallVec;
|
|
||||||
use std::collections::HashMap;
|
|
||||||
use std::sync::Arc;
|
|
||||||
|
|
||||||
pub mod attr;
|
|
||||||
pub mod group;
|
|
||||||
pub mod staging;
|
|
||||||
|
|
||||||
use attr::*;
|
|
||||||
use group::*;
|
|
||||||
use staging::*;
|
|
||||||
|
|
||||||
/// An error that can be returned when allocating a mesh.
|
|
||||||
pub enum PoolError {
|
|
||||||
TooBig,
|
|
||||||
NoMoreRoom,
|
|
||||||
InvalidIndex,
|
|
||||||
AttrTaken,
|
|
||||||
AttrUnregistered,
|
|
||||||
MismatchedId,
|
|
||||||
MismatchedLayout,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The number of attributes a mesh can have before they're moved to the heap.
|
|
||||||
pub const MAX_MESH_INLINE_ATTRIBUTES: usize = 16;
|
|
||||||
|
|
||||||
/// The data and layout of a single mesh attribute.
|
|
||||||
pub struct AttrBuffer {
|
|
||||||
pub id: AttrId,
|
|
||||||
pub layout: AttrLayout,
|
|
||||||
pub count: usize,
|
|
||||||
pub data: Vec<u8>,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A mesh and all of its attributes.
|
|
||||||
///
|
|
||||||
/// An attribute ID can be used multiple times in a mesh, corresponding to
|
|
||||||
/// multiple allocations within an [AttrPool].
|
|
||||||
pub struct MeshBuffer {
|
|
||||||
pub attributes: SmallVec<[AttrBuffer; MAX_MESH_INLINE_ATTRIBUTES]>,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A handle to an allocated mesh.
|
|
||||||
pub struct MeshHandle {
|
|
||||||
pub(crate) group: usize,
|
|
||||||
pub(crate) sub: usize,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl HasMeshHandle for MeshHandle {
|
|
||||||
fn get_mesh_handle(&self) -> &Self {
|
|
||||||
self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A trait for structs containing [MeshHandles][MeshHandle] that are not
|
|
||||||
/// themselves handles. Used for iteration.
|
|
||||||
pub trait HasMeshHandle {
|
|
||||||
fn get_mesh_handle(&self) -> &MeshHandle;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The top-level mesh data pool.
|
|
||||||
pub struct MeshPool {
|
|
||||||
staging: StagingPool,
|
|
||||||
attr_store: Arc<AttrStore>,
|
|
||||||
groups: Vec<MeshGroup>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl MeshPool {
|
|
||||||
pub fn new(attr_store: Arc<AttrStore>) -> Self {
|
|
||||||
Self {
|
|
||||||
staging: StagingPool::new(1_000_000),
|
|
||||||
attr_store,
|
|
||||||
groups: Default::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn load(&mut self, buf: &MeshBuffer) -> Result<MeshHandle, PoolError> {
|
|
||||||
for group in self.groups.iter_mut() {
|
|
||||||
match group.load(buf) {
|
|
||||||
Ok((handle, copies)) => {
|
|
||||||
self.staging.queue_copies(copies);
|
|
||||||
return Ok(handle);
|
|
||||||
}
|
|
||||||
Err(PoolError::NoMoreRoom) => {}
|
|
||||||
Err(e) => return Err(e),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
let group_index = self.groups.len();
|
|
||||||
let attr_store = self.attr_store.clone();
|
|
||||||
self.groups.push(MeshGroup::new(group_index, attr_store));
|
|
||||||
let group = self.groups.get_mut(group_index).unwrap();
|
|
||||||
|
|
||||||
let (handle, copies) = group.load(buf)?;
|
|
||||||
self.staging.queue_copies(copies);
|
|
||||||
Ok(handle)
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn iter_meshes<T: HasMeshHandle>(
|
|
||||||
&self,
|
|
||||||
meshes: impl IntoIterator<Item = T>,
|
|
||||||
) -> Vec<(&MeshGroup, Vec<(&MeshAlloc, T)>)> {
|
|
||||||
let group_num = self.groups.len();
|
|
||||||
let mut by_group = Vec::with_capacity(group_num);
|
|
||||||
for index in 0..group_num {
|
|
||||||
let group = self.groups.get(index);
|
|
||||||
let meshes = Vec::new();
|
|
||||||
by_group.push((group, meshes));
|
|
||||||
}
|
|
||||||
|
|
||||||
for mesh in meshes {
|
|
||||||
let handle = mesh.get_mesh_handle();
|
|
||||||
let (group, meshes) = match by_group.get_mut(handle.group) {
|
|
||||||
Some((Some(group), meshes)) => (group, meshes),
|
|
||||||
_ => continue,
|
|
||||||
};
|
|
||||||
|
|
||||||
let alloc = match group.get_alloc(handle) {
|
|
||||||
Some(alloc) => alloc,
|
|
||||||
None => continue, // TODO err out on invalid handle?
|
|
||||||
};
|
|
||||||
|
|
||||||
meshes.push((alloc, mesh));
|
|
||||||
}
|
|
||||||
|
|
||||||
by_group
|
|
||||||
.into_iter()
|
|
||||||
.filter_map(|(group, meshes)| group.map(|group| (group, meshes)))
|
|
||||||
.collect()
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,51 +0,0 @@
|
||||||
//! Intermediate CPU-mappable, GPU-visible storage for transferral to an attribute pool.
|
|
||||||
//!
|
|
||||||
//! TODO: double-buffered staging
|
|
||||||
|
|
||||||
use super::*;
|
|
||||||
use std::collections::VecDeque;
|
|
||||||
|
|
||||||
pub struct StagingPool {
|
|
||||||
stage_size: usize,
|
|
||||||
current_budget: usize,
|
|
||||||
copies: Vec<CopyInfo>,
|
|
||||||
spillover: VecDeque<SpilloverBuffer>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl StagingPool {
|
|
||||||
pub fn new(stage_size: usize) -> Self {
|
|
||||||
Self {
|
|
||||||
stage_size,
|
|
||||||
current_budget: 0,
|
|
||||||
copies: Default::default(),
|
|
||||||
spillover: Default::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn flush(&mut self) {
|
|
||||||
todo!()
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn queue_copies(&mut self, copies: Vec<CopyInfo>) {
|
|
||||||
todo!()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct CopyInfo {
|
|
||||||
/// The index of the target attribute pool's group.
|
|
||||||
pub group: usize,
|
|
||||||
|
|
||||||
/// The target attribute pool within the group.
|
|
||||||
pub target: AttrId,
|
|
||||||
|
|
||||||
/// The destination offset *in bytes.*
|
|
||||||
pub offset: usize,
|
|
||||||
|
|
||||||
/// The copy size *in bytes.*
|
|
||||||
pub size: usize,
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct SpilloverBuffer {
|
|
||||||
pub info: CopyInfo,
|
|
||||||
pub data: Vec<u8>,
|
|
||||||
}
|
|
Loading…
Reference in New Issue