tuioxide 0.3.1

A Rust implementation of the TUIO 1.1 and TUIO 2.0 protocols, providing both client and server components for sending and receiving multitouch and tangible object data over OSC.
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

use std::collections::HashSet;

use log::warn;
use rosc::{OscMessage, OscType};

use crate::{
    core::TuioError,
    tuio11::{blob::BlobProfile, cursor::CursorProfile, object::ObjectProfile},
};

#[derive(Debug, Clone, Default, Copy)]
pub(crate) enum TuioBundleType {
    Cursor,
    Object,
    Blob,
    #[default]
    Unknown,
}

#[derive(Debug, Clone, PartialEq)]
pub(crate) enum EntityType {
    Cursor(Vec<CursorProfile>),
    Object(Vec<ObjectProfile>),
    Blob(Vec<BlobProfile>),
}

#[derive(Debug, Clone, Default)]
pub(crate) struct TuioBundle {
    tuio_type: TuioBundleType,
    source: Option<String>,
    alive: HashSet<i32>,
    set: Option<EntityType>,
    fseq: i32,
}

impl TuioBundle {
    pub(crate) fn profile_type(&self) -> TuioBundleType {
        self.tuio_type
    }

    pub(crate) fn source(&self) -> &Option<String> {
        &self.source
    }

    pub(crate) fn alive(&self) -> &HashSet<i32> {
        &self.alive
    }

    pub(crate) fn tuio_entities(&self) -> &Option<EntityType> {
        &self.set
    }

    pub(crate) fn fseq(&self) -> i32 {
        self.fseq
    }

    pub(crate) fn set_type(&mut self, tuio_type: TuioBundleType) {
        self.tuio_type = tuio_type
    }

    pub(crate) fn set_source(&mut self, message: &OscMessage) {
        self.source = message.args.get(1).and_then(|arg| arg.clone().string());
    }

    pub(crate) fn set_alive(&mut self, message: &OscMessage) {
        self.alive = message
            .args
            .iter()
            .skip(1)
            .filter_map(|e| e.clone().int())
            .collect();
    }

    pub(crate) fn set_set(&mut self, message: &OscMessage) -> Result<(), TuioError> {
        match &self.tuio_type {
            TuioBundleType::Cursor => {
                if let EntityType::Cursor(set) =
                    self.set.get_or_insert(EntityType::Cursor(Vec::new()))
                {
                    if message.args.len() != 7 {
                        return Err(TuioError::MissingArguments(message.clone()));
                    }
                    let cursor = CursorProfile::try_from(message)?;
                    set.push(cursor);
                }
            }
            TuioBundleType::Object => {
                if let EntityType::Object(set) =
                    self.set.get_or_insert(EntityType::Object(Vec::new()))
                {
                    if message.args.len() != 11 {
                        return Err(TuioError::MissingArguments(message.clone()));
                    }
                    let object = ObjectProfile::try_from(message)?;
                    set.push(object);
                }
            }
            TuioBundleType::Blob => {
                if let EntityType::Blob(set) = self.set.get_or_insert(EntityType::Blob(Vec::new()))
                {
                    if message.args.len() != 13 {
                        return Err(TuioError::MissingArguments(message.clone()));
                    }
                    let blob = BlobProfile::try_from(message)?;
                    set.push(blob);
                }
            }
            TuioBundleType::Unknown => {
                warn!("Unknown Tuio Bundle Type")
            }
        }
        Ok(())
    }

    pub(crate) fn set_fseq(&mut self, message: &OscMessage) -> Result<(), TuioError> {
        if let Some(OscType::Int(fseq)) = message.args.get(1) {
            self.fseq = *fseq;
            Ok(())
        } else {
            Err(TuioError::MissingArguments(message.clone()))
        }
    }
}