megra_rs 0.0.6

A live-coding language with Markov chains.
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

use crate::generator::Generator;

use rosc::encoder;
use rosc::{OscMessage, OscPacket, OscType};

use std::collections::BTreeSet;
use std::net;
use std::str::FromStr;

pub struct VisualizerClient {
    pub host_addr: net::SocketAddrV4,
    pub to_addr: net::SocketAddrV4,
    pub socket: net::UdpSocket,
}

fn tags_to_string(tags: &BTreeSet<String>) -> String {
    let mut name: String = "".to_owned();
    for tag in tags.iter() {
        name.push_str(tag);
    }
    name
}

impl VisualizerClient {
    pub fn start() -> Self {
        let to_addr = net::SocketAddrV4::from_str("127.0.0.1:57121").unwrap();
        let host_addr = net::SocketAddrV4::from_str("127.0.0.1:57122").unwrap();
        VisualizerClient {
            host_addr,
            to_addr,
            socket: net::UdpSocket::bind(host_addr).unwrap(),
        }
    }

    pub fn create_or_update(&self, g: &Generator) {
        let gen_name = tags_to_string(&g.id_tags);
        // switch view
        let msg_buf_add = encoder::encode(&OscPacket::Message(OscMessage {
            addr: "/graph/add".to_string(),
            args: vec![OscType::String(gen_name.clone())],
        }))
        .unwrap();
        self.socket.send_to(&msg_buf_add, self.to_addr).unwrap();

        // nodes
        for (key, label) in g.root_generator.generator.labels.iter() {
            let msg_buf_node = encoder::encode(&OscPacket::Message(OscMessage {
                addr: "/node/add".to_string(),
                args: vec![
                    // needs full tag id
                    OscType::String(gen_name.clone()),
                    OscType::Int(*key as i32),
                    OscType::String(label.iter().collect()),
                ],
            }))
            .unwrap();
            self.socket.send_to(&msg_buf_node, self.to_addr).unwrap();
        }
        // edges
        for (src, children) in g.root_generator.generator.children.iter() {
            for ch in children.iter() {
                let msg_buf_edge = encoder::encode(&OscPacket::Message(OscMessage {
                    addr: "/edge/add".to_string(),
                    args: vec![
                        OscType::String(gen_name.clone()),
                        OscType::Int(*src as i32),
                        OscType::Int(ch.child_hash as i32),
                        OscType::String(ch.child.last().unwrap().to_string()),
                        OscType::Int((ch.prob * 100.0) as i32),
                    ],
                }))
                .unwrap();
                self.socket.send_to(&msg_buf_edge, self.to_addr).unwrap();
            }
        }

        // send render command ...
        let msg_buf_render = encoder::encode(&OscPacket::Message(OscMessage {
            addr: "/render".to_string(),
            args: vec![
                OscType::String(gen_name),
                OscType::String("cose".to_string()), // layout type
            ],
        }))
        .unwrap();
        self.socket.send_to(&msg_buf_render, self.to_addr).unwrap();
    }

    pub fn update_active_node(&self, g: &Generator) {
        let gen_name = tags_to_string(&g.id_tags);
        if let Some(h) = g.root_generator.generator.current_state {
            let msg_buf_active_node = encoder::encode(&OscPacket::Message(OscMessage {
                addr: "/node/active".to_string(),
                args: vec![OscType::String(gen_name), OscType::Int(h as i32)],
            }))
            .unwrap();
            self.socket
                .send_to(&msg_buf_active_node, self.to_addr)
                .unwrap();
        }
    }

    pub fn clear(&self, id_tags: &BTreeSet<String>) {
        let gen_name = tags_to_string(id_tags);
        let msg_buf_clear = encoder::encode(&OscPacket::Message(OscMessage {
            addr: "/clear".to_string(),
            args: vec![OscType::String(gen_name)],
        }))
        .unwrap();
        self.socket.send_to(&msg_buf_clear, self.to_addr).unwrap();
    }
}