Struct Server

pub struct Server {
    pub full_update: bool,
    pub object_profiling: bool,
    pub cursor_profiling: bool,
    pub blob_profiling: bool,
    /* private fields */
}

TUIO Server which keeps track of all TUIO elements and which send TUIO messages over the network

Fields

full_update: bool

Enables the full update of all currently active and inactive Objects, Cursors and Blobs

object_profiling: bool

cursor_profiling: bool

blob_profiling: bool

Implementations

impl Server

pub fn new(source_name: &str) -> Result<Self, Error>

Creates a TUIO Server with a default UdpSender configured for 127.0.0.1:3333

Arguments

• source_name - the source name

Examples found in repository

examples/send_and_receive.rs (line 35)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn from_socket_addr(socket_addr: SocketAddr) -> Result<Self, Error>

Creates a TUIO Server with a UdpSender configured from a provided socket address

Arguments

• socket_addr - a socket address SocketAddr

pub fn from_osc_sender( osc_sender: impl SendOsc<OscPacket, OscError> + 'static, ) -> Self

Creates a TUIO Server from an OSC sender implementing [OscSender] trait

Arguments

• osc_sender - a sender implementing [OscSender]

pub fn add_osc_sender( &mut self, osc_sender: impl SendOsc<OscPacket, OscError> + 'static, )

Adds an OSC sender implementing [OscSender] trait

Arguments

• osc_sender - a sender implementing [OscSender]

pub fn set_source_name(&mut self, name: &str)

Sets the server source name which is sent through the TUIO source message

Arguments

• name - the name of the source

pub fn enable_periodic_message(&mut self, interval: Option<Duration>)

Enables the periodic full update of all currently active TUIO Objects, Cursors and Blobs

Arguments

• interval - an option of a duration. Notes that the minimum interval will always be 10 milliseconds

pub fn disable_periodic_message(&mut self)

Disable the periodic full update of all currently active TUIO Objects, Cursors and Blobs

pub fn create_object( &mut self, class_id: i32, x: f32, y: f32, angle: f32, ) -> i32

Creates a TUIO Object and returns its session_id

Arguments

• class_id - a unique identifier that can be associated with a tangible object
• x - the object’s x position
• y - the object’s y position
• angle - the object’s angle

Examples found in repository

examples/send_and_receive.rs (line 39)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn update_object(&mut self, session_id: i32, x: f32, y: f32, angle: f32)

Updates a TUIO Object

Arguments

• session_id - the object’s session id
• x - the new object’s x position
• y - the new object’s y position
• angle - the new object’s angle

Examples found in repository

examples/send_and_receive.rs (line 50)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn remove_object(&mut self, session_id: i32)

Removes a TUIO Object

Arguments

• session_id - the object’s session id

Examples found in repository

examples/send_and_receive.rs (line 62)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn create_cursor(&mut self, x: f32, y: f32) -> i32

Creates a TUIO Cursor and returns its session_id

Arguments

• x - the cursor’s x position
• y - the cursor’s y position

Examples found in repository

examples/send_and_receive.rs (line 38)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn update_cursor(&mut self, session_id: i32, x: f32, y: f32)

Updates a TUIO Cursor

Arguments

• session_id - the cursor’s session id
• x - the new cursor’s x position
• y - the new cursor’s y position

Examples found in repository

examples/send_and_receive.rs (line 49)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn remove_cursor(&mut self, session_id: i32)

Removes a TUIO Cursor

Arguments

• session_id - the cursor’s session id

Examples found in repository

examples/send_and_receive.rs (line 61)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn create_blob( &mut self, x: f32, y: f32, angle: f32, width: f32, height: f32, area: f32, ) -> i32

Creates a TUIO Blob and returns its session_id

Arguments

• x - the blob’s x position
• y - the blob’s y position
• angle - the blob’s angle
• width - the blob’s width
• height - the blob’s height
• area - the blob’s area

Examples found in repository

examples/send_and_receive.rs (line 40)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn update_blob( &mut self, session_id: i32, x: f32, y: f32, angle: f32, width: f32, height: f32, area: f32, )

Updates a TUIO Blob

Arguments

• session_id - the blob’s session id
• x - the new blob’s x position
• y - the new blob’s y position
• angle - the new blob’s angle
• width - the new blob’s width
• height - the new blob’s height
• area - the new blob’s area

Examples found in repository

examples/send_and_receive.rs (line 51)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn remove_blob(&mut self, session_id: i32)

Removes a TUIO Blob

Arguments

• session_id - the blob’s session id

Examples found in repository

examples/send_and_receive.rs (line 63)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn init_frame(&mut self)

Initializes a new frame.

Examples found in repository

examples/send_and_receive.rs (line 37)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn commit_frame(&mut self)

Commits the current frame.

Generates and sends TUIO messages of all currently active and updated Objects, Cursors and Blobs

Examples found in repository

examples/send_and_receive.rs (line 41)

fn main() {
    let client = Client::new().unwrap();
    client.connect().expect("Client connecting");

    let mut server = Server::new("server_name").unwrap();
    
    server.init_frame();
    let cursor_id = server.create_cursor(0., 0.);
    let object_id = server.create_object(1, 0., 0., 0.);
    let blob_id = server.create_blob(0., 0., 0., 0.1, 0.1, 0.01);
    server.commit_frame();
    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.update_cursor(cursor_id, 1., 1.);
    server.update_object(object_id, 1., 1., 90f32.to_radians());
    server.update_blob(blob_id, 1., 1., 90f32.to_radians(), 0.2, 0.2, 0.04);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }

    server.init_frame();
    server.remove_cursor(cursor_id);
    server.remove_object(object_id);
    server.remove_blob(blob_id);
    server.commit_frame();

    std::thread::sleep(Duration::from_secs(1));

    if let Ok(Some(events)) = client.refresh() {
        process_events(events);
    }
}

pub fn send_full_messages(&self)

Trait Implementations

impl Drop for Server

fn drop(&mut self)

Executes the destructor for this type.