draco_decoder 0.0.21

a draco decoder on rust (wip)
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AttributeDataType {
    Int8,
    UInt8,
    Int16,
    UInt16,
    Int32,
    UInt32,
    Float32,
}

impl AttributeDataType {
    pub fn size_in_bytes(&self) -> usize {
        match self {
            AttributeDataType::Int8 | AttributeDataType::UInt8 => 1,
            AttributeDataType::Int16 | AttributeDataType::UInt16 => 2,
            AttributeDataType::Int32 | AttributeDataType::UInt32 | AttributeDataType::Float32 => 4,
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct MeshAttribute {
    dim: u32,
    data_type: AttributeDataType,
    offset: u32,
    lenght: u32,
}

impl MeshAttribute {
    pub fn new(dim: u32, data_type: AttributeDataType, offset: u32, lenght: u32) -> Self {
        Self {
            dim,
            data_type,
            offset,
            lenght,
        }
    }

    pub fn offset(&self) -> u32 {
        self.offset
    }

    pub fn lenght(&self) -> u32 {
        self.lenght
    }

    pub fn data_type(&self) -> AttributeDataType {
        self.data_type
    }

    pub fn dim(&self) -> u32 {
        self.dim
    }
}

#[derive(Debug, PartialEq, Eq)]
pub struct DracoDecodeConfig {
    vertex_count: u32,
    index_count: u32,
    index_length: u32,
    attributes: Vec<MeshAttribute>,
}

impl DracoDecodeConfig {
    pub fn new(vertex_count: u32, index_count: u32) -> Self {
        let index_length = if index_count <= u16::MAX as u32 {
            index_count as usize * 2
        } else {
            index_count as usize * 4
        } as u32;

        Self {
            vertex_count,
            index_count,
            index_length,
            attributes: Vec::new(),
        }
    }

    pub fn index_length(&self) -> u32 {
        self.index_length
    }

    pub fn add_attribute(&mut self, dim: u32, data_type: AttributeDataType) {
        let offset = self.estimate_buffer_size() as u32;
        let lenght = dim * self.vertex_count * data_type.size_in_bytes() as u32;
        let attribute = MeshAttribute {
            dim,
            data_type,
            offset,
            lenght,
        };
        self.attributes.push(attribute);
    }

    pub fn get_attribute(&self, index: usize) -> Option<&MeshAttribute> {
        self.attributes.get(index)
    }

    pub fn attributes(&self) -> Vec<MeshAttribute> {
        self.attributes.clone()
    }

    pub fn vertex_count(&self) -> u32 {
        self.vertex_count
    }

    pub fn index_count(&self) -> u32 {
        self.index_count
    }
}

impl DracoDecodeConfig {
    pub fn estimate_buffer_size(&self) -> usize {
        let mut size = 0;

        let index_bytes = if self.index_count <= u16::MAX as u32 {
            (self.index_count as usize) * 2
        } else {
            (self.index_count as usize) * 4
        };
        size += index_bytes;

        for attr in &self.attributes {
            let attr_data_size =
                (attr.dim as usize) * (self.vertex_count as usize) * attr.data_type.size_in_bytes();
            size += attr_data_size;
        }

        size
    }
}

#[derive(Debug)]
pub enum AttributeValues {
    Int8(Vec<i8>),
    UInt8(Vec<u8>),
    Int16(Vec<i16>),
    UInt16(Vec<u16>),
    Int32(Vec<i32>),
    UInt32(Vec<u32>),
    Float32(Vec<f32>),
}

#[derive(Debug)]
pub struct MeshDecodeResult {
    pub data: Vec<u8>,
    pub config: DracoDecodeConfig,
}