use std::sync::Arc;
use unityrs_core::limits::{Meter, MeteredVec};
use crate::error::{IndexKind, MeshError};
use crate::vertex::field;
use unityrs_core::objmode::Obj;
const MAX_BITS: u64 = 32;
fn nan(r: f64, a: f64, b: f64) -> f64 {
const QUIET: u64 = 0x0008_0000_0000_0000;
if !r.is_nan() {
r
} else if a.is_nan() {
f64::from_bits(a.to_bits() | QUIET)
} else if b.is_nan() {
f64::from_bits(b.to_bits() | QUIET)
} else {
r
}
}
pub(crate) fn add(a: f64, b: f64) -> f64 {
nan(a + b, a, b)
}
pub(crate) fn sub(a: f64, b: f64) -> f64 {
nan(a - b, a, b)
}
pub(crate) fn mul(a: f64, b: f64) -> f64 {
nan(a * b, a, b)
}
pub(crate) fn div(a: f64, b: f64) -> f64 {
nan(a / b, a, b)
}
pub(crate) fn size(n: u64) -> usize {
usize::try_from(n).unwrap_or(usize::MAX)
}
pub(crate) fn unpack_ints(
packed: &Obj<'_>,
start: u64,
count: Option<u64>,
meter: &Arc<Meter>,
) -> Result<MeteredVec<u32>, MeshError> {
let bits = packed
.uint("m_BitSize", u64::from(u8::MAX))?
.ok_or(MeshError::Assertion(""))?;
let data = packed
.ints("m_Data")?
.ok_or(MeshError::NoAttribute("m_Data"))?;
let count = match count {
Some(n) => n,
None => field(packed, "m_NumItems", u64::from(u32::MAX))?,
};
if bits > MAX_BITS && count > 0 {
return Err(MeshError::malformed(
format_args!("a packed item wider than 32 bits"),
meter,
));
}
let first = u128::from(bits) * u128::from(start);
let end = u128::from(bits) * (u128::from(start) + u128::from(count));
let len = data.len();
if bits > 0 && count > 0 && end.div_ceil(8) > len as u128 {
let from = size(u64::try_from(first / 8).unwrap_or(u64::MAX)).min(len);
meter.count_decode(u64::try_from(len - from).unwrap_or(u64::MAX))?;
for i in from..len {
data.item(i)?;
}
return Err(MeshError::Index(if data.is_bytes() {
IndexKind::Bytes
} else {
IndexKind::List
}));
}
let mut out = MeteredVec::<u32>::with_capacity(meter, size(count))?;
meter.count_decode(count)?;
let mut index = size(u64::try_from(first / 8).unwrap_or(u64::MAX));
let mut bit = u32::try_from(first % 8).unwrap_or(0);
let width = u32::try_from(bits).unwrap_or(0);
for _ in 0..count {
let mut got = 0u32;
let mut value = 0u64;
while got < width {
let byte = data.item(index)?.ok_or(MeshError::Index(IndexKind::List))?;
value |= u64::from(byte >> bit) << got;
let num = (width - got).min(8 - bit);
bit += num;
got += num;
if bit == 8 {
index += 1;
bit = 0;
}
}
let mask = (1u64 << width) - 1;
out.push(u32::try_from(value & mask).unwrap_or(u32::MAX))?;
}
Ok(out)
}
pub(crate) fn unpack_floats(
packed: &Obj<'_>,
start: u64,
count: Option<u64>,
meter: &Arc<Meter>,
) -> Result<MeteredVec<f64>, MeshError> {
let bits = packed
.uint("m_BitSize", u64::from(u8::MAX))?
.ok_or(MeshError::Assertion(""))?;
let range = packed.float("m_Range")?.ok_or(MeshError::Assertion(""))?;
let first = packed.float("m_Start")?.ok_or(MeshError::Assertion(""))?;
if bits == 0 {
let n = match count {
Some(n) => n,
None => field(packed, "m_NumItems", u64::from(u32::MAX))?,
};
let mut out = MeteredVec::<f64>::with_capacity(meter, size(n))?;
meter.count_decode(n)?;
for _ in 0..n {
out.push(first)?;
}
return Ok(out);
}
let ints = unpack_ints(packed, start, count, meter)?;
let mut out = MeteredVec::<f64>::with_capacity(meter, ints.len())?;
meter.count_decode(u64::try_from(ints.len()).unwrap_or(u64::MAX))?;
let steps = f64::from(u32::try_from((1u64 << bits.min(MAX_BITS)) - 1).unwrap_or(u32::MAX));
let scale = div(range, steps);
for &x in ints.as_slice() {
out.push(add(mul(f64::from(x), scale), first))?;
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::{add, div, mul, sub};
#[test]
fn a_nan_operand_gives_its_own_nan() {
let a = f64::from_bits(0x7ff8_0000_0000_0001);
let b = f64::from_bits(0xfff0_0000_0000_0002);
assert_eq!(add(a, b).to_bits(), a.to_bits());
assert_eq!(sub(b, a).to_bits(), 0xfff8_0000_0000_0002);
assert_eq!(mul(2.0, b).to_bits(), 0xfff8_0000_0000_0002);
assert_eq!(div(a, 3.0).to_bits(), a.to_bits());
assert_eq!(add(1.5, 2.25), 3.75);
}
}