use meshopt_rs::index::buffer::decode_index_buffer;
use meshopt_rs::index::sequence::decode_index_sequence;
use meshopt_rs::vertex::buffer::decode_vertex_buffer;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mode {
Attributes,
Triangles,
Indices,
}
impl Mode {
pub fn parse(name: &str) -> Option<Self> {
match name {
"ATTRIBUTES" => Some(Self::Attributes),
"TRIANGLES" => Some(Self::Triangles),
"INDICES" => Some(Self::Indices),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Filter {
None,
Octahedral,
Quaternion,
Exponential,
}
impl Filter {
pub fn parse(name: &str) -> Option<Self> {
match name {
"NONE" => Some(Self::None),
"OCTAHEDRAL" => Some(Self::Octahedral),
"QUATERNION" => Some(Self::Quaternion),
"EXPONENTIAL" => Some(Self::Exponential),
_ => None,
}
}
}
pub fn decode_gltf_buffer(
count: usize,
stride: usize,
source: &[u8],
mode: Mode,
filter: Filter,
) -> Result<Vec<u8>, String> {
check(count, stride, mode, filter)?;
let malformed = |error: &dyn std::fmt::Debug| format!("malformed buffer data ({error:?})");
let mut target = match mode {
Mode::Attributes => decode_vertices(count, stride, source).map_err(|e| malformed(&e))?,
Mode::Triangles | Mode::Indices => {
let mut indices = vec![0u32; count];
if mode == Mode::Triangles {
decode_index_buffer(&mut indices, source).map_err(|e| malformed(&e))?;
} else {
decode_index_sequence(&mut indices, source).map_err(|e| malformed(&e))?;
}
if stride == 2 {
indices
.iter()
.flat_map(|&i| (i as u16).to_le_bytes())
.collect()
} else {
indices.iter().flat_map(|&i| i.to_le_bytes()).collect()
}
}
};
match (filter, stride) {
(Filter::None, _) => {}
(Filter::Octahedral, 4) => filter_oct_8(&mut target),
(Filter::Octahedral, _) => filter_oct_16(&mut target),
(Filter::Quaternion, _) => filter_quat(&mut target),
(Filter::Exponential, _) => filter_exp(&mut target),
}
Ok(target)
}
fn check(count: usize, stride: usize, mode: Mode, filter: Filter) -> Result<(), String> {
let fine = match mode {
Mode::Attributes => stride > 0 && stride <= 256 && stride.is_multiple_of(4),
Mode::Triangles => (stride == 2 || stride == 4) && count.is_multiple_of(3),
Mode::Indices => stride == 2 || stride == 4,
} && match filter {
Filter::None => true,
_ if mode != Mode::Attributes => false,
Filter::Octahedral => stride == 4 || stride == 8,
Filter::Quaternion => stride == 8,
Filter::Exponential => true,
};
if fine {
Ok(())
} else {
Err(format!(
"mode {mode:?}, filter {filter:?}, count {count} and byteStride {stride} do not go together"
))
}
}
fn decode_vertices(
count: usize,
stride: usize,
source: &[u8],
) -> Result<Vec<u8>, meshopt_rs::vertex::DecodeError> {
macro_rules! strides {
($($n:literal)*) => {
match stride {
$($n => {
let mut vertices = vec![[0u8; $n]; count];
decode_vertex_buffer(&mut vertices, source)?;
Ok(vertices.concat())
})*
_ => unreachable!("`check` allows no other stride"),
}
};
}
strides!(
4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64
68 72 76 80 84 88 92 96 100 104 108 112 116 120 124 128
132 136 140 144 148 152 156 160 164 168 172 176 180 184 188 192
196 200 204 208 212 216 220 224 228 232 236 240 244 248 252 256
)
}
fn snap(value: f32) -> i32 {
(value + 12_582_912.0).to_bits() as i32
}
fn fold(x: f32, t: f32) -> f32 {
x + f32::from_bits(t.to_bits() ^ (x.to_bits() & 0x8000_0000))
}
fn negative_part(z: f32) -> f32 {
f32::from_bits((z.to_bits() as i32).min(0) as u32)
}
fn oct(x: f32, y: f32, z: f32, max: f32) -> (i32, i32, i32) {
let z = z - (x.abs() + y.abs());
let t = negative_part(z);
let x = fold(x, t);
let y = fold(y, t);
let ll = x * x + (y * y + z * z);
let s = max / ll.sqrt();
(snap(x * s), snap(y * s), snap(z * s))
}
fn filter_oct_8(data: &mut [u8]) {
for v in data.as_chunks_mut::<4>().0 {
let (x, y, z) = oct(
v[0] as i8 as f32,
v[1] as i8 as f32,
v[2] as i8 as f32,
127.0,
);
v[0] = x as u8;
v[1] = y as u8;
v[2] = z as u8;
}
}
fn filter_oct_16(data: &mut [u8]) {
for v in data.as_chunks_mut::<8>().0 {
let (x, y, z) = oct(
i16::from_le_bytes([v[0], v[1]]) as f32,
i16::from_le_bytes([v[2], v[3]]) as f32,
(u16::from_le_bytes([v[4], v[5]]) & 0x7fff) as f32,
32767.0,
);
v[0..2].copy_from_slice(&(x as u16).to_le_bytes());
v[2..4].copy_from_slice(&(y as u16).to_le_bytes());
v[4..6].copy_from_slice(&(z as u16).to_le_bytes());
}
}
fn filter_quat(data: &mut [u8]) {
let scale = 32767.0f32 / 2.0f32.sqrt();
for q in data.as_chunks_mut::<8>().0 {
let c = |i: usize| i16::from_le_bytes([q[2 * i], q[2 * i + 1]]) as i32;
let (x, y, z, cf) = (c(0) as f32, c(1) as f32, c(2) as f32, c(3));
let s = (cf | 3) as f32;
let ws = s * s;
let ww = (ws + ws) - (x * x + (y * y + z * z));
let w = f32::from_bits((ww.to_bits() as i32).max(0) as u32).sqrt();
let ss = scale / s;
let out = [snap(w * ss), snap(x * ss), snap(y * ss), snap(z * ss)];
let qc = (cf & 3) as usize;
for (k, value) in out.into_iter().enumerate() {
let at = 2 * ((qc + k) & 3);
q[at..at + 2].copy_from_slice(&(value as u16).to_le_bytes());
}
}
}
fn filter_exp(data: &mut [u8]) {
for v in data.as_chunks_mut::<4>().0 {
let word = i32::from_le_bytes([v[0], v[1], v[2], v[3]]);
let e = word >> 24;
let m = (word << 8) >> 8;
let power = f32::from_bits((e.wrapping_add(127) << 23) as u32);
v.copy_from_slice(&(power * m as f32).to_le_bytes());
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn exp_is_ldexp() {
let word = |e: i32, m: i32| -> [u8; 4] { ((e << 24) | (m & 0xff_ffff)).to_le_bytes() };
let mut data = [word(-3, 12), word(2, -5), word(0, 0)].concat();
filter_exp(&mut data);
let floats: Vec<f32> = data
.as_chunks::<4>()
.0
.iter()
.map(|&b| f32::from_le_bytes(b))
.collect();
assert_eq!(floats, [1.5, -20.0, 0.0]);
}
#[test]
fn quat_identity() {
let mut data = [0i16, 0, 0, 0x7ffc]
.iter()
.flat_map(|c| c.to_le_bytes())
.collect::<Vec<u8>>();
filter_quat(&mut data);
let out: Vec<i16> = data
.as_chunks::<2>()
.0
.iter()
.map(|&b| i16::from_le_bytes(b))
.collect();
assert_eq!(out, [32767, 0, 0, 0]);
}
#[test]
fn bad_combinations_are_errors() {
assert!(decode_gltf_buffer(3, 6, &[], Mode::Attributes, Filter::None).is_err());
assert!(decode_gltf_buffer(4, 2, &[], Mode::Triangles, Filter::None).is_err());
assert!(decode_gltf_buffer(3, 3, &[], Mode::Indices, Filter::None).is_err());
assert!(decode_gltf_buffer(1, 12, &[], Mode::Attributes, Filter::Octahedral).is_err());
assert!(
decode_gltf_buffer(3, 2, &[0xe1; 64], Mode::Triangles, Filter::Exponential).is_err()
);
assert!(decode_gltf_buffer(1, 4, &[0x00; 64], Mode::Attributes, Filter::None).is_err());
}
}