use crate::codec::{self, BufferView, IndexEncoding, VertexEncoding};
use crate::workspace::checked_bytes;
use crate::{
Attributes, Error, Limits, MeshletSettings, Meshlets, Positions, SimplifiedMesh,
SimplifySettings, VertexFlags, Workspace,
};
use alloc::vec::Vec;
use core::mem::size_of;
use rayon::prelude::*;
use std::cell::RefCell;
pub type BatchResult<T> = Result<Vec<Result<T, Error>>, Error>;
std::thread_local! {
static WORKSPACE: RefCell<Workspace> = RefCell::new(Workspace::default());
}
fn slots<T>(count: usize) -> BatchResult<T> {
checked_bytes(count, size_of::<Result<T, Error>>())?;
let mut result = Vec::new();
result
.try_reserve_exact(count)
.map_err(|_| Error::AllocationFailed)?;
result.resize_with(count, || Err(Error::AllocationFailed));
Ok(result)
}
fn item<T>(
limits: Limits,
run: impl FnOnce(&mut Workspace) -> Result<T, Error>,
) -> Result<T, Error> {
WORKSPACE.with(|cell| {
let mut workspace = cell.borrow_mut();
workspace.set_limits(limits);
let result = run(&mut workspace);
workspace.clear();
result
})
}
fn batch<I: Sync, T: Send>(
inputs: &[I],
limits: Limits,
run: impl Fn(&I, &mut Workspace) -> Result<T, Error> + Sync,
) -> BatchResult<T> {
let mut result = slots(inputs.len())?;
result
.par_iter_mut()
.zip(inputs.par_iter())
.for_each(|(out, input)| {
*out = item(limits, |workspace| run(input, workspace));
});
Ok(result)
}
#[derive(Clone, Copy, Debug)]
pub struct LodAttributes<'a> {
pub attributes: Attributes<'a>,
pub weights: &'a [f32],
pub vertex_flags: Option<&'a [VertexFlags]>,
}
#[derive(Clone, Copy, Debug)]
pub struct LodChainInput<'a> {
pub indices: &'a [u32],
pub positions: Positions<'a>,
pub levels: &'a [SimplifySettings],
pub attributes: Option<LodAttributes<'a>>,
}
pub fn simplify_lod_chain(
input: &LodChainInput<'_>,
workspace: &mut Workspace,
) -> Result<Vec<SimplifiedMesh>, Error> {
let mut work = workspace.begin();
let result = (|| {
let limits = workspace.limits();
let retained = workspace.retained_bytes()?;
let mut levels =
crate::budget::Budget::new(workspace).reserved::<SimplifiedMesh>(input.levels.len())?;
let mut live = checked_bytes(levels.capacity(), size_of::<SimplifiedMesh>())?;
let mut spent = 0u64;
for &settings in input.levels {
work.add(1)?;
spent = spent.checked_add(1).ok_or(Error::SizeOverflow)?;
let mut child = Workspace::new(Limits {
max_bytes: limits
.max_bytes
.checked_sub(retained.checked_add(live).ok_or(Error::SizeOverflow)?)
.ok_or(Error::LimitExceeded)?,
max_work: limits
.max_work
.checked_sub(spent)
.ok_or(Error::LimitExceeded)?,
});
let indices = levels.last().map_or(input.indices, |level| &level.indices);
let result = match input.attributes {
None => crate::simplify(indices, input.positions, settings, &mut child),
Some(a) => crate::simplify_with_attributes(
indices,
input.positions,
a.attributes,
a.weights,
a.vertex_flags,
settings,
&mut child,
),
};
work.add_processing(child.usage().work)?;
spent = spent
.checked_add(child.usage().work)
.ok_or(Error::SizeOverflow)?;
workspace.charge_owned(
retained,
live.checked_add(child.usage().bytes)
.ok_or(Error::SizeOverflow)?,
)?;
let level = result?;
live = live
.checked_add(checked_bytes(level.indices.capacity(), 4)?)
.ok_or(Error::SizeOverflow)?;
levels.push(level);
}
Ok(levels)
})();
workspace.finish(&work);
result
}
pub fn simplify_lod_chains_batch(
inputs: &[LodChainInput<'_>],
limits: Limits,
) -> BatchResult<Vec<SimplifiedMesh>> {
batch(inputs, limits, simplify_lod_chain)
}
#[derive(Clone, Copy, Debug)]
pub enum EncodeInput<'a> {
Vertices {
vertices: &'a [u8],
count: usize,
stride: usize,
encoding: VertexEncoding,
},
Triangles {
indices: &'a [u32],
encoding: IndexEncoding,
},
Sequence {
indices: &'a [u32],
encoding: IndexEncoding,
},
}
impl EncodeInput<'_> {
pub fn encode(self, workspace: &mut Workspace) -> Result<Vec<u8>, Error> {
match self {
Self::Vertices {
vertices,
count,
stride,
encoding,
} => codec::encode_vertex_buffer(vertices, count, stride, encoding, workspace),
Self::Triangles { indices, encoding } => {
codec::encode_index_buffer(indices, encoding, workspace)
}
Self::Sequence { indices, encoding } => {
codec::encode_index_sequence(indices, encoding, workspace)
}
}
}
}
pub fn encode_buffers_batch(inputs: &[EncodeInput<'_>], limits: Limits) -> BatchResult<Vec<u8>> {
batch(inputs, limits, |input, workspace| input.encode(workspace))
}
#[derive(Clone, Copy, Debug)]
pub struct DecodeInput<'a> {
pub view: BufferView,
pub source: &'a [u8],
}
pub fn decode_buffer_views_batch(
inputs: &[DecodeInput<'_>],
limits: Limits,
) -> BatchResult<Vec<u8>> {
batch(inputs, limits, |input, workspace| {
input.view.decode(input.source, workspace)
})
}
#[derive(Clone, Copy, Debug)]
pub enum MeshletBuilder {
Scan,
Standard {
cone_weight: f32,
},
Flex {
min_triangles: usize,
cone_weight: f32,
split_factor: f32,
},
Spatial {
min_triangles: usize,
fill_weight: f32,
},
}
#[derive(Clone, Copy, Debug)]
pub struct MeshletInput<'a> {
pub indices: &'a [u32],
pub positions: Positions<'a>,
pub settings: MeshletSettings,
pub builder: MeshletBuilder,
}
impl MeshletInput<'_> {
pub fn build(self, workspace: &mut Workspace) -> Result<Meshlets, Error> {
let Self {
indices,
positions,
settings,
builder,
} = self;
match builder {
MeshletBuilder::Scan => {
crate::build_meshlets_scan(indices, positions.len(), settings, workspace)
}
MeshletBuilder::Standard { cone_weight } => {
crate::build_meshlets(indices, positions, settings, cone_weight, workspace)
}
MeshletBuilder::Flex {
min_triangles,
cone_weight,
split_factor,
} => crate::build_meshlets_flex(
indices,
positions,
settings,
min_triangles,
cone_weight,
split_factor,
workspace,
),
MeshletBuilder::Spatial {
min_triangles,
fill_weight,
} => crate::build_meshlets_spatial(
indices,
positions,
settings,
min_triangles,
fill_weight,
workspace,
),
}
}
}
pub fn build_meshlets_batch(inputs: &[MeshletInput<'_>], limits: Limits) -> BatchResult<Meshlets> {
batch(inputs, limits, |input, workspace| input.build(workspace))
}
#[cfg(feature = "clusterlod")]
pub struct ClusterLodInput<'a> {
pub config: crate::clusterlod::Config,
pub mesh: crate::clusterlod::Mesh<'a>,
}
#[cfg(feature = "clusterlod")]
pub fn build_cluster_lod_batch(
inputs: &mut [ClusterLodInput<'_>],
limits: Limits,
) -> BatchResult<Vec<crate::clusterlod::GroupOutput>> {
let mut result = slots(inputs.len())?;
result
.par_iter_mut()
.zip(inputs.par_iter_mut())
.for_each(|(out, input)| {
*out = item(limits, |workspace| {
crate::clusterlod::build(
input.config,
crate::clusterlod::Mesh {
indices: input.mesh.indices,
positions: &mut *input.mesh.positions,
attributes: input.mesh.attributes,
vertex_lock: input.mesh.vertex_lock,
attribute_weights: input.mesh.attribute_weights,
attribute_protect_mask: input.mesh.attribute_protect_mask,
},
workspace,
)
});
});
Ok(result)
}
#[cfg(feature = "clusterlod")]
#[derive(Clone, Copy, Debug)]
pub struct ClusterHierarchyInput<'a> {
pub groups: &'a [crate::clusterlod::Group],
pub node_width: usize,
pub level_count: usize,
}
#[cfg(feature = "clusterlod")]
pub fn build_cluster_hierarchies_batch(
inputs: &[ClusterHierarchyInput<'_>],
limits: Limits,
) -> BatchResult<Vec<crate::clusterlod::Node>> {
let (groups, visits) = inputs.iter().fold((0usize, 0usize), |(groups, visits), i| {
(
groups.saturating_add(i.groups.len()),
visits.saturating_add(i.groups.len().saturating_mul(i.level_count.max(1))),
)
});
let run = |input: &ClusterHierarchyInput<'_>, workspace: &mut Workspace| {
crate::clusterlod::build_hierarchy(
input.groups,
input.node_width,
input.level_count,
workspace,
)
};
if groups <= 256 && visits <= 2048 {
let mut result = slots(inputs.len())?;
for (out, input) in result.iter_mut().zip(inputs) {
*out = item(limits, |workspace| run(input, workspace));
}
Ok(result)
} else {
batch(inputs, limits, run)
}
}