use std::sync::Arc;
use unityrs_core::limits::{Charge, Meter, MeteredVec};
use crate::Version;
use crate::error::{IndexKind, MeshError};
use crate::format::MeshTopology;
use crate::vertex::field;
use unityrs_core::objmode::{Obj, SUB_MESH};
#[derive(Debug)]
pub struct Triangles {
submeshes: Vec<SubMeshTriangles>,
_charge: Charge,
}
const _: () = crate::send_sync::<Triangles>();
impl Triangles {
#[must_use]
pub fn from_submeshes(submeshes: MeteredVec<SubMeshTriangles>) -> Self {
let (submeshes, charge) = submeshes.into_parts();
Self {
submeshes,
_charge: charge,
}
}
#[must_use]
pub fn empty(meter: &Arc<Meter>) -> Self {
Self {
submeshes: Vec::new(),
_charge: Charge::zero(meter),
}
}
#[must_use]
pub fn submeshes(&self) -> &[SubMeshTriangles] {
&self.submeshes
}
}
#[derive(Debug)]
pub struct SubMeshTriangles {
triangles: Vec<[u32; 3]>,
cut: [u32; 2],
cut_len: u8,
empty: u64,
index_count: u64,
_charge: Charge,
}
const _: () = crate::send_sync::<SubMeshTriangles>();
impl SubMeshTriangles {
#[must_use]
pub fn from_triangles(triangles: MeteredVec<[u32; 3]>) -> Self {
let (triangles, charge) = triangles.into_parts();
let index_count = (triangles.len() as u64).saturating_mul(3);
Self {
triangles,
cut: [0; 2],
cut_len: 0,
empty: 0,
index_count,
_charge: charge,
}
}
#[must_use]
pub fn triangles(&self) -> &[[u32; 3]] {
&self.triangles
}
#[must_use]
pub fn cut(&self) -> &[u32] {
self.cut
.get(..usize::from(self.cut_len))
.unwrap_or_default()
}
#[must_use]
pub fn empty(&self) -> u64 {
self.empty
}
#[must_use]
pub fn len(&self) -> u64 {
u64::try_from(self.triangles.len())
.unwrap_or(u64::MAX)
.saturating_add(u64::from(self.cut_len > 0))
.saturating_add(self.empty)
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
#[must_use]
pub fn index_count(&self) -> u64 {
self.index_count
}
}
pub(crate) fn get_triangles(
src: &Obj<'_>,
version: Version,
use_16bit: bool,
buffer: Option<&[u32]>,
meter: &Arc<Meter>,
) -> Result<Triangles, MeshError> {
let buffer = buffer.ok_or(MeshError::Assertion(""))?;
let subs = src
.list("m_SubMeshes", &SUB_MESH)?
.ok_or(MeshError::Assertion(""))?;
let mut out = MeteredVec::<SubMeshTriangles>::with_capacity(meter, subs.len())?;
meter.count_decode(u64::try_from(subs.len()).unwrap_or(u64::MAX))?;
for sub in subs.iter() {
let sub = sub?;
let mut first = field(&sub, "firstByte", u64::from(u32::MAX))? / 2;
if !use_16bit {
first /= 2;
}
let count = field(&sub, "indexCount", u64::from(u32::MAX))?;
let topology = sub.int32("topology")?;
let is = |t: MeshTopology| topology == Some(t.value());
let one = if is(MeshTopology::Triangles) {
list(buffer, first, count, meter)?
} else if version.major()? < 4 || is(MeshTopology::TriangleStrip) {
strip(buffer, first, count, meter)?
} else if is(MeshTopology::Quads) {
quads(buffer, first, count, meter)?
} else {
return Err(MeshError::Topology);
};
out.push(one)?;
}
let (submeshes, charge) = out.into_parts();
Ok(Triangles {
submeshes,
_charge: charge,
})
}
fn at(buffer: &[u32], i: u64) -> u32 {
usize::try_from(i)
.ok()
.and_then(|i| buffer.get(i))
.copied()
.unwrap_or(0)
}
fn len64(buffer: &[u32]) -> u64 {
u64::try_from(buffer.len()).unwrap_or(u64::MAX)
}
fn list(
buffer: &[u32],
first: u64,
count: u64,
meter: &Arc<Meter>,
) -> Result<SubMeshTriangles, MeshError> {
let n = len64(buffer);
let tuples = count.div_ceil(3);
let whole = if n >= first.saturating_add(3) {
tuples.min((n - first) / 3)
} else {
0
};
let mut triangles =
MeteredVec::<[u32; 3]>::with_capacity(meter, usize::try_from(whole).unwrap_or(usize::MAX))?;
meter.count_decode(whole.saturating_mul(12))?;
for k in 0..whole {
let i = first + 3 * k;
triangles.push([at(buffer, i), at(buffer, i + 1), at(buffer, i + 2)])?;
}
let mut cut = [0u32; 2];
let mut cut_len = 0u8;
let mut rest = tuples - whole;
if rest > 0 {
let i = first.saturating_add(3 * whole);
if i < n {
let left = n - i;
cut = [at(buffer, i), if left > 1 { at(buffer, i + 1) } else { 0 }];
cut_len = u8::try_from(left.min(2)).unwrap_or(2);
rest -= 1;
}
}
let (triangles, charge) = triangles.into_parts();
Ok(SubMeshTriangles {
triangles,
cut,
cut_len,
empty: rest,
index_count: count,
_charge: charge,
})
}
fn strip(
buffer: &[u32],
first: u64,
count: u64,
meter: &Arc<Meter>,
) -> Result<SubMeshTriangles, MeshError> {
let end = len64(buffer);
let steps = count.saturating_sub(2);
if steps > 0 && first.saturating_add(count) > end {
let failing = first.max(end.saturating_sub(2));
let got = u8::try_from(end.saturating_sub(failing)).unwrap_or(0);
return Err(MeshError::Unpack { expected: 3, got });
}
let mut triangles =
MeteredVec::<[u32; 3]>::with_capacity(meter, usize::try_from(steps).unwrap_or(usize::MAX))?;
meter.count_decode(steps.saturating_mul(12))?;
for k in 0..steps {
let pos = first + k;
let (a, b, c) = (at(buffer, pos), at(buffer, pos + 1), at(buffer, pos + 2));
if a == b || a == c || b == c {
continue;
}
triangles.push(if k & 1 == 1 { [b, a, c] } else { [a, b, c] })?;
}
let kept = u64::try_from(triangles.len()).unwrap_or(u64::MAX);
let (triangles, charge) = triangles.into_parts();
Ok(SubMeshTriangles {
triangles,
cut: [0; 2],
cut_len: 0,
empty: 0,
index_count: kept.saturating_mul(3),
_charge: charge,
})
}
fn quads(
buffer: &[u32],
first: u64,
count: u64,
meter: &Arc<Meter>,
) -> Result<SubMeshTriangles, MeshError> {
let end = len64(buffer);
let quads = count.div_ceil(4);
let unpacked = if end >= first.saturating_add(4) {
(end - first - 4) / 4 + 1
} else {
0
};
if unpacked < quads {
let failing = first.saturating_add(4 * unpacked);
let got = u8::try_from(end.saturating_sub(failing)).unwrap_or(0);
return Err(MeshError::Unpack { expected: 4, got });
}
if !count.is_multiple_of(4) {
return Err(MeshError::Index(IndexKind::ListAssignment));
}
let len = quads.saturating_mul(2);
let mut triangles =
MeteredVec::<[u32; 3]>::with_capacity(meter, usize::try_from(len).unwrap_or(usize::MAX))?;
meter.count_decode(len.saturating_mul(12))?;
for q in 0..quads {
let pos = first + 4 * q;
let (a, b, c, d) = (
at(buffer, pos),
at(buffer, pos + 1),
at(buffer, pos + 2),
at(buffer, pos + 3),
);
triangles.push([a, b, c])?;
triangles.push([a, c, d])?;
}
let (triangles, charge) = triangles.into_parts();
Ok(SubMeshTriangles {
triangles,
cut: [0; 2],
cut_len: 0,
empty: 0,
index_count: count,
_charge: charge,
})
}