use crate::codec::{self, BufferView, IndexEncoding, VertexEncoding};
use crate::workspace::checked_bytes;
use crate::{
Attributes, Error, Limits, MeshletSettings, Meshlets, MeshletsGeneric, Positions,
SimplifiedMesh, SimplifiedMeshGeneric, 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)
}
#[cfg(feature = "clusterlod")]
fn batch_mut<I: Send, T: Send>(
inputs: &mut [I],
limits: Limits,
run: impl Fn(&mut I, &mut Workspace) -> Result<T, Error> + Sync,
) -> BatchResult<T> {
let mut result = slots(inputs.len())?;
result
.par_iter_mut()
.zip(inputs.par_iter_mut())
.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 LodChainInputGeneric<'a, I: crate::Index = u32> {
pub indices: &'a [I],
pub positions: Positions<'a>,
pub levels: &'a [SimplifySettings],
pub attributes: Option<LodAttributes<'a>>,
}
pub fn simplify_lod_chain_generic<I: crate::Index>(
input: &LodChainInputGeneric<'_, I>,
workspace: &mut Workspace,
) -> Result<Vec<SimplifiedMeshGeneric<I>>, Error> {
let mut work = workspace.begin();
let result = (|| {
let limits = workspace.limits();
workspace.release_unused();
let mut levels = crate::budget::Budget::new(workspace)
.reserved::<SimplifiedMeshGeneric<I>>(input.levels.len())?;
let mut live = checked_bytes(levels.capacity(), size_of::<SimplifiedMeshGeneric<I>>())?;
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(live)
.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_generic(indices, input.positions, settings, &mut child),
Some(a) => crate::simplify_with_attributes_generic(
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(
live.checked_add(child.usage().bytes)
.ok_or(Error::SizeOverflow)?,
)?;
let level = result?;
live = live
.checked_add(checked_bytes(level.indices.capacity(), size_of::<I>())?)
.ok_or(Error::SizeOverflow)?;
levels.push(level);
}
Ok(levels)
})();
workspace.finish(&work);
result
}
pub fn simplify_lod_chains_batch_generic<I: crate::Index>(
inputs: &[LodChainInputGeneric<'_, I>],
limits: Limits,
) -> BatchResult<Vec<SimplifiedMeshGeneric<I>>> {
batch(inputs, limits, simplify_lod_chain_generic)
}
#[derive(Clone, Copy, Debug)]
pub enum EncodeInputGeneric<'a, I: crate::Index = u32> {
Vertices {
vertices: &'a [u8],
count: usize,
stride: usize,
encoding: VertexEncoding,
},
Triangles {
indices: &'a [I],
encoding: IndexEncoding,
},
Sequence {
indices: &'a [I],
encoding: IndexEncoding,
},
}
impl<I: crate::Index> EncodeInputGeneric<'_, I> {
pub fn encode_generic(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_generic(indices, encoding, workspace)
}
Self::Sequence { indices, encoding } => {
codec::encode_index_sequence_generic(indices, encoding, workspace)
}
}
}
}
pub fn encode_buffers_batch_generic<I: crate::Index>(
inputs: &[EncodeInputGeneric<'_, I>],
limits: Limits,
) -> BatchResult<Vec<u8>> {
batch(inputs, limits, |input, workspace| {
input.encode_generic(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 MeshletInputGeneric<'a, I: crate::Index = u32> {
pub indices: &'a [I],
pub positions: Positions<'a>,
pub settings: MeshletSettings,
pub builder: MeshletBuilder,
}
impl<I: crate::Index> MeshletInputGeneric<'_, I> {
pub fn build_generic(self, workspace: &mut Workspace) -> Result<MeshletsGeneric<I>, Error> {
let Self {
indices,
positions,
settings,
builder,
} = self;
match builder {
MeshletBuilder::Scan => {
crate::build_meshlets_scan_generic(indices, positions.len(), settings, workspace)
}
MeshletBuilder::Standard { cone_weight } => {
crate::build_meshlets_generic(indices, positions, settings, cone_weight, workspace)
}
MeshletBuilder::Flex {
min_triangles,
cone_weight,
split_factor,
} => crate::build_meshlets_flex_generic(
indices,
positions,
settings,
min_triangles,
cone_weight,
split_factor,
workspace,
),
MeshletBuilder::Spatial {
min_triangles,
fill_weight,
} => crate::build_meshlets_spatial_generic(
indices,
positions,
settings,
min_triangles,
fill_weight,
workspace,
),
}
}
}
pub fn build_meshlets_batch_generic<I: crate::Index>(
inputs: &[MeshletInputGeneric<'_, I>],
limits: Limits,
) -> BatchResult<MeshletsGeneric<I>> {
batch(inputs, limits, |input, workspace| {
input.build_generic(workspace)
})
}
#[cfg(feature = "clusterlod")]
pub struct ClusterLodInputGeneric<'a, I: crate::Index = u32> {
pub config: crate::clusterlod::Config,
pub mesh: crate::clusterlod::MeshGeneric<'a, I>,
}
#[cfg(feature = "clusterlod")]
pub fn build_cluster_lod_batch_generic<I: crate::Index>(
inputs: &mut [ClusterLodInputGeneric<'_, I>],
limits: Limits,
) -> BatchResult<Vec<crate::clusterlod::GroupOutputGeneric<I>>> {
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_generic(
input.config,
crate::clusterlod::MeshGeneric {
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)
}
}
#[cfg(feature = "clusterlod")]
pub struct DagBuildInputGeneric<'a, I: crate::Index = u32> {
pub config: crate::clusterlod::Config,
pub mesh: crate::clusterlod::MeshGeneric<'a, I>,
pub node_width: usize,
pub destination: crate::clusterlod::DagBuffersGeneric<'a, I>,
}
#[cfg(feature = "clusterlod")]
pub fn build_dags_batch_into_generic<I: crate::Index>(
inputs: &mut [DagBuildInputGeneric<'_, I>],
limits: Limits,
) -> BatchResult<crate::clusterlod::DagCounts> {
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_dag_into_generic(
input.config,
crate::clusterlod::MeshGeneric {
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,
},
input.node_width,
crate::clusterlod::DagBuffersGeneric {
vertex_source: &mut *input.destination.vertex_source,
vertex_positions: &mut *input.destination.vertex_positions,
indices: &mut *input.destination.indices,
clusters: &mut *input.destination.clusters,
groups: &mut *input.destination.groups,
nodes: &mut *input.destination.nodes,
},
workspace,
)
});
});
Ok(result)
}
#[inline]
pub fn simplify_lod_chain(
input: &LodChainInput<'_>,
workspace: &mut Workspace,
) -> Result<Vec<SimplifiedMesh>, Error> {
simplify_lod_chain_generic::<u32>(&(*input).into(), workspace)
.map(|values| values.into_iter().map(Into::into).collect())
}
pub fn encode_vertex_buffer_parallel(
vertices: &[u8],
count: usize,
stride: usize,
encoding: VertexEncoding,
workspace: &mut Workspace,
) -> Result<Vec<u8>, Error> {
codec::encode_vertex_buffer_parallel(vertices, count, stride, encoding, workspace)
}
pub fn decode_vertex_buffer_parallel(
count: usize,
stride: usize,
source: &[u8],
workspace: &mut Workspace,
) -> Result<Vec<u8>, Error> {
codec::decode_vertex_buffer_parallel(count, stride, source, workspace)
}
#[inline]
pub fn build_meshlets_spatial_parallel_generic<I: crate::Index>(
indices: &[I],
p: Positions<'_>,
s: MeshletSettings,
min_triangles: usize,
fill_weight: f32,
workspace: &mut Workspace,
) -> Result<MeshletsGeneric<I>, Error> {
crate::meshlet::build_meshlets_spatial_parallel_generic(
indices,
p,
s,
min_triangles,
fill_weight,
workspace,
)
}
#[inline]
pub fn build_meshlets_spatial_parallel(
indices: &[u32],
p: Positions<'_>,
s: MeshletSettings,
min_triangles: usize,
fill_weight: f32,
workspace: &mut Workspace,
) -> Result<Meshlets, Error> {
build_meshlets_spatial_parallel_generic::<u32>(
indices,
p,
s,
min_triangles,
fill_weight,
workspace,
)
.map(Into::into)
}
#[inline]
pub fn simplify_lod_chains_batch(
inputs: &[LodChainInput<'_>],
limits: Limits,
) -> BatchResult<Vec<SimplifiedMesh>> {
batch(inputs, limits, simplify_lod_chain)
}
#[inline]
pub fn encode_buffers_batch(inputs: &[EncodeInput<'_>], limits: Limits) -> BatchResult<Vec<u8>> {
batch(inputs, limits, |input, workspace| input.encode(workspace))
}
#[inline]
pub fn build_meshlets_batch(inputs: &[MeshletInput<'_>], limits: Limits) -> BatchResult<Meshlets> {
batch(inputs, limits, |input, workspace| input.build(workspace))
}
#[cfg(feature = "clusterlod")]
#[inline]
pub fn build_cluster_lod_batch(
inputs: &mut [ClusterLodInput<'_>],
limits: Limits,
) -> BatchResult<Vec<crate::clusterlod::GroupOutput>> {
batch_mut(inputs, limits, |input, workspace| {
crate::clusterlod::build(
input.config,
crate::clusterlod::Mesh {
indices: input.mesh.indices,
positions: 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,
)
})
}
#[cfg(feature = "clusterlod")]
#[inline]
pub fn build_dags_batch_into(
inputs: &mut [DagBuildInput<'_>],
limits: Limits,
) -> BatchResult<crate::clusterlod::DagCounts> {
batch_mut(inputs, limits, |input, workspace| {
crate::clusterlod::build_dag_into(
input.config,
crate::clusterlod::Mesh {
indices: input.mesh.indices,
positions: 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,
},
input.node_width,
crate::clusterlod::DagBuffers {
vertex_source: input.destination.vertex_source,
vertex_positions: input.destination.vertex_positions,
indices: input.destination.indices,
clusters: input.destination.clusters,
groups: input.destination.groups,
nodes: input.destination.nodes,
},
workspace,
)
})
}
impl MeshletInput<'_> {
#[inline]
pub fn build(self, workspace: &mut Workspace) -> Result<Meshlets, Error> {
MeshletInputGeneric::from(self)
.build_generic(workspace)
.map(Into::into)
}
}
#[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>>,
}
impl<'a> From<LodChainInputGeneric<'a, u32>> for LodChainInput<'a> {
#[inline]
fn from(value: LodChainInputGeneric<'a, u32>) -> Self {
Self {
indices: value.indices,
positions: value.positions,
levels: value.levels,
attributes: value.attributes,
}
}
}
impl<'a> From<LodChainInput<'a>> for LodChainInputGeneric<'a, u32> {
#[inline]
fn from(value: LodChainInput<'a>) -> Self {
Self {
indices: value.indices,
positions: value.positions,
levels: value.levels,
attributes: value.attributes,
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct MeshletInput<'a> {
pub indices: &'a [u32],
pub positions: Positions<'a>,
pub settings: MeshletSettings,
pub builder: MeshletBuilder,
}
impl<'a> From<MeshletInputGeneric<'a, u32>> for MeshletInput<'a> {
#[inline]
fn from(value: MeshletInputGeneric<'a, u32>) -> Self {
Self {
indices: value.indices,
positions: value.positions,
settings: value.settings,
builder: value.builder,
}
}
}
impl<'a> From<MeshletInput<'a>> for MeshletInputGeneric<'a, u32> {
#[inline]
fn from(value: MeshletInput<'a>) -> Self {
Self {
indices: value.indices,
positions: value.positions,
settings: value.settings,
builder: value.builder,
}
}
}
#[cfg(feature = "clusterlod")]
pub struct ClusterLodInput<'a> {
pub config: crate::clusterlod::Config,
pub mesh: crate::clusterlod::Mesh<'a>,
}
#[cfg(feature = "clusterlod")]
impl<'a> From<ClusterLodInputGeneric<'a, u32>> for ClusterLodInput<'a> {
#[inline]
fn from(value: ClusterLodInputGeneric<'a, u32>) -> Self {
Self {
config: value.config,
mesh: value.mesh.into(),
}
}
}
#[cfg(feature = "clusterlod")]
impl<'a> From<ClusterLodInput<'a>> for ClusterLodInputGeneric<'a, u32> {
#[inline]
fn from(value: ClusterLodInput<'a>) -> Self {
Self {
config: value.config,
mesh: value.mesh.into(),
}
}
}
#[cfg(feature = "clusterlod")]
pub struct DagBuildInput<'a> {
pub config: crate::clusterlod::Config,
pub mesh: crate::clusterlod::Mesh<'a>,
pub node_width: usize,
pub destination: crate::clusterlod::DagBuffers<'a>,
}
#[cfg(feature = "clusterlod")]
impl<'a> From<DagBuildInputGeneric<'a, u32>> for DagBuildInput<'a> {
#[inline]
fn from(value: DagBuildInputGeneric<'a, u32>) -> Self {
Self {
config: value.config,
mesh: value.mesh.into(),
node_width: value.node_width,
destination: value.destination.into(),
}
}
}
#[cfg(feature = "clusterlod")]
impl<'a> From<DagBuildInput<'a>> for DagBuildInputGeneric<'a, u32> {
#[inline]
fn from(value: DagBuildInput<'a>) -> Self {
Self {
config: value.config,
mesh: value.mesh.into(),
node_width: value.node_width,
destination: value.destination.into(),
}
}
}
#[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> {
let generic = match self {
Self::Vertices {
vertices,
count,
stride,
encoding,
} => EncodeInputGeneric::Vertices {
vertices,
count,
stride,
encoding,
},
Self::Triangles { indices, encoding } => {
EncodeInputGeneric::Triangles { indices, encoding }
}
Self::Sequence { indices, encoding } => {
EncodeInputGeneric::Sequence { indices, encoding }
}
};
generic.encode_generic(workspace)
}
}