ponk-protocol 0.1.0

Zero-dependency Rust codec and bounded reassembler for the PONK laser-path protocol
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

//! Encode a frame to datagrams and decode it back — no sockets involved.
//!
//! Run with: `cargo run --example roundtrip`

use ponk_protocol::{
    DataFormat, PonkFrame, PonkMetadata, PonkPath, PonkPoint, decode_datagram, encode_datagrams,
};

fn main() {
    let frame = PonkFrame {
        sender_id: 1,
        sender_name: "roundtrip-example".to_string(),
        frame_number: 0,
        paths: vec![PonkPath {
            metadata: vec![PonkMetadata {
                key: "PATHNUMB".to_string(),
                value: 0.0,
            }],
            points: vec![
                PonkPoint {
                    x: -0.5,
                    y: -0.5,
                    rgb: [255, 0, 0],
                },
                PonkPoint {
                    x: 0.5,
                    y: 0.5,
                    rgb: [0, 255, 0],
                },
            ],
        }],
    };

    let datagrams =
        encode_datagrams(&frame, DataFormat::XyF32RgbU8, 1200).expect("frame should encode");
    println!("encoded into {} datagram(s)", datagrams.len());

    let decoded = decode_datagram(&datagrams[0])
        .expect("valid datagram")
        .expect("single-chunk frame");

    println!(
        "decoded frame from '{}' with {} path(s), {} point(s)",
        decoded.sender_name,
        decoded.paths.len(),
        decoded.paths[0].points.len(),
    );
    assert_eq!(decoded.paths[0].points, frame.paths[0].points);
    println!("roundtrip ok");
}