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

use crate::core::attribute::ComponentDataType;
use crate::core::shared::DataValue;
use crate::core::shared::{AttributeValueIdx, Vector};
use crate::prelude::Attribute;
use crate::prelude::ByteWriter;
use crate::prelude::NdVector;
use crate::shared::attribute::Portable;

#[cfg(feature = "evaluation")]
use crate::eval;

use super::Config;
use super::PortabilizationImpl;

pub struct ToBits<Data, const N: usize>
where
    Data: Vector<N>,
{
    /// The attribute to portabilize.
    att: Attribute,

    _marker: std::marker::PhantomData<Data>,
}

impl<Data, const N: usize> ToBits<Data, N>
where
    Data: Vector<N> + Portable,
    Data::Component: DataValue,
{
    pub fn new<W>(att: Attribute, _cfg: Config, _writer: &mut W) -> Self
    where
        W: ByteWriter,
    {
        #[cfg(feature = "evaluation")]
        eval::write_json_pair("portabilization", "ToBits".into(), _writer);

        Self {
            att,
            _marker: std::marker::PhantomData,
        }
    }
}

impl<Data, const N: usize> PortabilizationImpl<N> for ToBits<Data, N>
where
    Data: Vector<N> + Portable,
    Data::Component: DataValue,
    NdVector<N, i32>: Vector<N, Component = i32>,
{
    fn portabilize(self) -> Attribute {
        // Convert all values to i32 if it is not already i32.

        if self.att.get_component_type() == ComponentDataType::I32 {
            return self.att;
        }

        let mut out = Vec::with_capacity(self.att.num_unique_values());
        for i in 0..self.att.num_unique_values() {
            let i = AttributeValueIdx::from(i);
            let val: Data = self.att.get_unique_val(i);
            let mut converted = NdVector::<N, i32>::zero();
            for j in 0..N {
                *converted.get_mut(j) = val.get(j).to_i64() as i32;
            }
            out.push(converted);
        }

        let mut port_att = Attribute::from_without_removing_duplicates(
            self.att.get_id(),
            out,
            self.att.get_attribute_type(),
            self.att.get_domain(),
            self.att.get_parents().clone(),
        );
        port_att.set_point_to_att_val_map(self.att.take_point_to_att_val_map());
        port_att
    }
}