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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::{
    core::bit_coder::ReaderErr,
    prelude::{ByteReader, ByteWriter},
};

pub mod prediction;
pub mod symbol_encoder;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct TopologySplit {
    pub merging_symbol_idx: usize,
    pub split_symbol_idx: usize,
    pub merging_edge_orientation: Orientation,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum Orientation {
    Left,
    Right,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[allow(dead_code)] // This enum is not used yet, as we only support the default configuration.
pub(crate) enum EdgebreakerKind {
    Standard,
    Predictive,
    Valence,
}

impl EdgebreakerKind {
    #[allow(unused)] // TODO: Remove this function when the decoder is complete
    pub(crate) fn read_from<R>(reader: &mut R) -> Result<Self, Err>
    where
        R: ByteReader,
    {
        let traversal_type = reader.read_u8()?;
        match traversal_type {
            0 => Ok(Self::Standard),
            1 => Ok(Self::Predictive),
            2 => Ok(Self::Valence),
            _ => Err(Err::InvalidTraversalType(traversal_type)),
        }
    }

    pub(crate) fn write_to<W>(self, writer: &mut W)
    where
        W: ByteWriter,
    {
        let traversal_type = match self {
            Self::Standard => 0,
            Self::Predictive => 1,
            Self::Valence => 2,
        };
        writer.write_u8(traversal_type);
    }
}

pub(crate) const MAX_VALENCE: usize = 7;
pub(crate) const MIN_VALENCE: usize = 2;

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum TraversalType {
    DepthFirst,
    #[allow(dead_code)]
    // This variant is not used yet. We might not implement this and may simply remove it in the future.
    PredictionDegree,
}

impl TraversalType {
    #[allow(unused)] // TODO: Remove this function when the decoder is complete
    pub(crate) fn read_from<R>(reader: &mut R) -> Result<Self, Err>
    where
        R: ByteReader,
    {
        let traversal_type = reader.read_u8()?;
        match traversal_type {
            0 => Ok(Self::DepthFirst),
            1 => Ok(Self::PredictionDegree),
            _ => Err(Err::InvalidTraversalType(traversal_type)),
        }
    }

    pub(crate) fn write_to<W>(self, writer: &mut W)
    where
        W: ByteWriter,
    {
        let traversal_type = match self {
            Self::DepthFirst => 0,
            Self::PredictionDegree => 1,
        };
        writer.write_u8(traversal_type);
    }
}

#[derive(Debug, thiserror::Error, PartialEq)]
pub enum Err {
    #[error("Invalid traversal type: {0}")]
    InvalidTraversalType(u8),
    #[error("Reader error")]
    ReaderError(#[from] ReaderErr),
}

#[allow(unused)] // This enum is not used yet, as we only support the default configuration.
pub(crate) enum SymbolRansEncodingConfig {
    LengthCoded,
    DirectCoded,
}

impl SymbolRansEncodingConfig {
    #[allow(unused)] // This function is not used yet, as we only support the default configuration.
    pub(crate) fn read_from<R>(reader: &mut R) -> Result<Self, Err>
    where
        R: ByteReader,
    {
        let config = reader.read_u8()?;
        match config {
            0 => Ok(Self::LengthCoded),
            1 => Ok(Self::DirectCoded),
            _ => Err(Err::InvalidTraversalType(config)),
        }
    }

    #[allow(unused)] // TODO: Remove this.
    pub(crate) fn write_to<W>(self, writer: &mut W)
    where
        W: ByteWriter,
    {
        let config = match self {
            Self::LengthCoded => 0,
            Self::DirectCoded => 1,
        };
        writer.write_u8(config);
    }
}