draco-rs 0.1.3

Rust-bindings to the c++ draco library, for compressing and decompressing 3D geometric meshes and point clouds.
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

use crate::prelude::*;
use autocxx::prelude::*;

pub type Encoder = WrappedDracoObject<ffi::draco::Encoder>;

impl Encoder {
    pub fn new() -> Self {
        let encoder = ffi::draco::Encoder::new().within_unique_ptr();
        Self(encoder)
    }

    pub fn set_attribute_quantization(
        mut self,
        attr: ffi::draco::GeometryAttribute_Type,
        num_bits: i32,
    ) -> Self {
        self.0
            .pin_mut()
            .SetAttributeQuantization(attr, num_bits.into());
        self
    }

    pub fn set_speed_options(mut self, encoding_speed: i32, decoding_speed: i32) -> Self {
        self.0
            .pin_mut()
            .SetSpeedOptions(encoding_speed.into(), decoding_speed.into());
        self
    }
}
impl Default for Encoder {
    fn default() -> Self {
        Self::new()
    }
}

pub type EncoderBuffer = WrappedDracoObject<ffi::draco::EncoderBuffer>;

impl EncoderBuffer {
    pub fn new() -> Self {
        let buffer = ffi::draco::EncoderBuffer::new().within_unique_ptr();
        Self(buffer)
    }

    pub fn as_mut_ptr(&mut self) -> *mut ffi::draco::EncoderBuffer {
        self.0.as_mut_ptr()
    }

    pub fn clear(&mut self) {
        self.0.pin_mut().Clear();
    }

    pub fn resize(&mut self, size: i64) {
        self.0.pin_mut().Resize(size);
    }

    /// Returns a pointer to the data in the buffer
    pub fn data(&self) -> *const std::os::raw::c_char {
        self.0.data()
    }

    // Returns the size of the buffer in bytes
    pub fn size(&self) -> usize {
        self.0.size()
    }

    /// Returns a slice of the buffer
    ///
    /// # Safety
    ///
    /// The pointer must be valid for the lifetime of the buffer
    pub fn as_slice(&self) -> &[u8] {
        // cast the pointer to a slice of u8
        unsafe { std::slice::from_raw_parts(self.data() as *const u8, self.size()) }
    }
}

impl Default for EncoderBuffer {
    fn default() -> Self {
        Self::new()
    }
}