draco-oxide 0.1.0-alpha.5

draco-oxide is a rust rewrite of Google's draco mesh compression library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

mod sequential;
mod spirale_reversi;
use crate::core::bit_coder::ReaderErr;
use crate::core::shared::{FaceIdx, VertexIdx}; 
use crate::debug_expect;
use crate::decode::header::Header;
use crate::prelude::ByteReader;
use crate::shared::connectivity::EdgebreakerDecoder;
use crate::shared::header::EncoderMethod;

#[derive(Debug, thiserror::Error)]
pub enum Err {
    #[error("Sequential decoding error: {0}")]
    SequentialError(#[from] sequential::Err),
    
    #[error("Spirale Reversi decoding error: {0}")]
    SpiraleReversiError(#[from] spirale_reversi::Err),

    #[error("Not enough data in stream")]
    NotEnoughData(#[from] ReaderErr),
}

pub fn decode_connectivity_att<R>(reader: &mut R, header: Header) -> Result<Vec<[FaceIdx;3]>, Err>
    where R: ByteReader,
{
    let connectivity = match header.encoding_method {
        EncoderMethod::Edgebreaker => {
            debug_expect!("Start of edgebreaker connectivity", reader);
            let mut decoder = spirale_reversi::SpiraleReversi::new();
            decoder.decode_connectivity(reader)?
        },
        EncoderMethod::Sequential => {
            debug_expect!("Start of sequential connectivity", reader);
            let mut decoder = sequential::Sequential;
            decoder.decode_connectivity(reader)?
        }
    };

    Ok(connectivity)
}


pub trait ConnectivityDecoder {
    type Err;
    fn decode_connectivity<R>(&mut self, reader: &mut R) -> Result<Vec<[VertexIdx; 3]>, Self::Err>
        where R: ByteReader;
}