Update

8 files changed, 236 insertions, 371 deletions

diff --git a/crates/renderer/src/main.rs b/crates/renderer/src/main.rs
index 35111f2..ae8cc03 100644
--- a/crates/renderer/src/main.rs
+++ b/crates/renderer/src/main.rs
@@ -30,7 +30,6 @@ pub fn main() -> Erm<()> {
                     Box::new(overlay::automata::Overlay::new(ctx)),
                     Box::new(overlay::shader::Overlay::new(ctx)),
                     Box::new(overlay::drawing::Overlay::new(ctx)),
-                    Box::new(overlay::irish::Overlay::new(ctx)),
                     Box::new(overlay::tcg::Overlay::new(ctx)),
                     // Box::new(overlay::model::Overlay::new(ctx)),
                     // Box::new(overlay::loopback::Overlay::new(ctx)),
diff --git a/crates/renderer/src/overlay.rs b/crates/renderer/src/overlay.rs
index bd0a24d..af02eda 100644
--- a/crates/renderer/src/overlay.rs
+++ b/crates/renderer/src/overlay.rs
@@ -2,22 +2,20 @@ pub mod model;
 pub mod shader;
 pub mod drawing;
 pub mod automata;
-pub mod irish;
 pub mod tcg;
 pub mod loopback;
 
 use teleia::*;
 
 use std::f32::consts::PI;
-use lexpr::sexp;
-use base64::prelude::*;
+use byteorder::{LE, ReadBytesExt};
 
 use crate::{assets, fig, toggle, input, background};
 
 pub struct Chat {
     author: String,
     msg: String,
-    time: f64,
+    time: f32,
     biblicality: f32,
 }
 impl Chat {
@@ -30,19 +28,27 @@ impl Chat {
         }
     }
 }
+
+pub struct Tracking {
+    eyes: (f32, f32),
+    mouth: f32,
+    neck: glam::Quat,
+}
+
+pub struct Info {
+    mouse_cursor: (f32, f32),
+    emacs_cursor: (f32, f32),
+    emacs_heartrate: i32,
+    muzak_author: Option<String>,
+}
+
 pub struct State {
     assets: assets::Assets,
     model: scene::Scene,
     model_neck_base: glam::Mat4,
-    fig: fig::SexpClient,
     fig_binary: fig::BinaryClient,
-    tracking_eyes: (f32, f32),
-    tracking_mouth: f32,
-    tracking_neck: glam::Quat,
-    emacs_cursor: (f32, f32),
-    mouse_cursor: (f32, f32),
-    emacs_heartrate: i32,
-    muzak_author: Option<String>,
+    tracking: Tracking,
+    info: Info,
     chat: Chat,
     toggles: toggle::Toggles,
     input: input::Input,
@@ -59,36 +65,35 @@ impl State {
             assets: assets::Assets::new(ctx),
             model,
             model_neck_base,
-            fig: fig::SexpClient::new("shiro:32050", &[
-                sexp!((avatar toggle)),
-                sexp!((avatar toggle set)),
-                sexp!((avatar toggle unset)),
-                sexp!((avatar text)),
-                sexp!((avatar frame)),
-                sexp!((avatar reset)),
-                sexp!((avatar tracking)),
-                sexp!((avatar overlay shader)),
-                sexp!((avatar overlay muzak)),
-                sexp!((avatar overlay muzak clear)),
-                sexp!((avatar overlay chat)),
-                sexp!((avatar overlay cursor)),
-                sexp!((avatar overlay emacs)),
-                sexp!((avatar automata spawn)),
-                sexp!((overlay irish start)),
-                sexp!((overlay irish update)),
-                sexp!((overlay irish save)),
-            ]),
-            fig_binary: fig::BinaryClient::new("shiro:32051", false, &[
-                b"background frame",
+            fig_binary: fig::BinaryClient::new("shiro:32051", &[
+                b"overlay reset",
+                b"overlay tracking",
+                b"overlay background frame",
+                b"overlay toggle",
+                b"overlay toggle set",
+                b"overlay toggle unset",
+                b"overlay info emacs",
+                b"overlay info emacs cursor",
+                b"overlay info credits music",
+                b"overlay info credits music clear",
+                b"overlay chat",
+                b"overlay avatar text",
+                b"overlay shader",
+                b"overlay shader chat",
+                b"overlay automata spawn",
                 b"overlay tcg generate",
-            ]),
-            tracking_eyes: (1.0, 1.0),
-            tracking_mouth: 0.0,
-            tracking_neck: glam::Quat::IDENTITY,
-            emacs_cursor: (0.0, 0.0),
-            mouse_cursor: (0.0, 0.0),
-            emacs_heartrate: 0,
-            muzak_author: None,
+            ]).expect("failed to connect to bus"),
+            tracking: Tracking {
+                eyes: (1.0, 1.0),
+                mouth: 0.0,
+                neck: glam::Quat::IDENTITY,
+            },
+            info: Info {
+                emacs_cursor: (0.0, 0.0),
+                mouse_cursor: (0.0, 0.0),
+                emacs_heartrate: 0,
+                muzak_author: None,
+            },
             chat: Chat::new(),
             toggles: toggle::Toggles::new(),
             backgrounds: background::Backgrounds::new(ctx),
@@ -98,53 +103,6 @@ impl State {
     fn reset(&mut self, ctx: &context::Context, st: &mut state::State) {
         self.toggles.reset();
     }
-    pub fn handle_tracking(&mut self, msg: fig::SexpMessage) -> Option<()> {
-        let eyes = msg.data.get(0)?;
-        let eye_left = eyes.get(0)?.as_str()?.parse::<f32>().ok()?;
-        let eye_right = eyes.get(1)?.as_str()?.parse::<f32>().ok()?;
-        let mouth = msg.data.get(1)?.as_str()?.parse::<f32>().ok()?;
-        let euler = msg.data.get(2)?;
-        let euler_x = euler.get(0)?.as_str()?.parse::<f32>().ok()?.to_radians();
-        let euler_y = PI - euler.get(1)?.as_str()?.parse::<f32>().ok()?.to_radians();
-        let euler_z = euler.get(2)?.as_str()?.parse::<f32>().ok()?.to_radians() + PI/2.0;
-        self.tracking_eyes = (eye_left, eye_right);
-        self.tracking_mouth = mouth;
-        self.tracking_neck = glam::Quat::from_euler(glam::EulerRot::XYZ, euler_x, euler_y, euler_z);
-        Some(())
-    }
-    fn handle_overlay_muzak(&mut self, msg: fig::SexpMessage) -> Option<()> {
-        let ba = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
-        let author = String::from_utf8_lossy(&ba);
-        self.muzak_author = Some(author.to_string());
-        Some(())
-    }
-    fn handle_overlay_muzak_clear(&mut self) -> Option<()> {
-        self.muzak_author = None;
-        Some(())
-    }
-    fn handle_overlay_chat(&mut self, msg: fig::SexpMessage) -> Option<()> {
-        let ba = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
-        let a = String::from_utf8_lossy(&ba);
-        let bs = BASE64_STANDARD.decode(msg.data.get(1)?.as_str()?).ok()?;
-        let s = String::from_utf8_lossy(&bs);
-        let time = msg.data.get(2)?.as_str()?.parse::<f64>().ok()?;
-        let biblicality = msg.data.get(3)?.as_str()?.parse::<f32>().ok()?;
-        self.chat.author = a.to_string();
-        self.chat.msg = s.to_string();
-        self.chat.time = time;
-        self.chat.biblicality = biblicality;
-        Some(())
-    }
-    fn handle_overlay_cursor(&mut self, msg: fig::SexpMessage) -> Option<()> {
-        let cursor_x = msg.data.get(0)?.as_i64()? as f32;
-        let cursor_y = msg.data.get(1)?.as_i64()? as f32;
-        self.emacs_cursor = (cursor_x, cursor_y);
-        Some(())
-    }
-    fn handle_overlay_emacs(&mut self, msg: fig::SexpMessage) -> Option<()> {
-        self.emacs_heartrate = msg.data.get(0)?.as_i64()? as i32;
-        Some(())
-    }
     fn update(&mut self, ctx: &context::Context, st: &mut state::State) -> Erm<()> {
         st.move_camera(
             ctx,
@@ -153,9 +111,10 @@ impl State {
             &glam::Vec3::new(0.0, 1.0, 0.0),
         );
         let (x, y) = self.input.get_mouse();
-        self.mouse_cursor = (x as f32, y as f32);
+        self.info.mouse_cursor = (x as f32, y as f32);
+        // update model head transform based on tracking state
         if let Some(n) = self.model.nodes_by_name.get("J_Bip_C_Neck").and_then(|i| self.model.nodes.get_mut(*i)) {
-            n.transform = self.model_neck_base * glam::Mat4::from_quat(self.tracking_neck);
+            n.transform = self.model_neck_base * glam::Mat4::from_quat(self.tracking.neck);
         }
         Ok(())
     }
@@ -168,10 +127,7 @@ pub trait Overlay {
     fn update(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut State) -> Erm<()> {
         Ok(())
     }
-    fn handle(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut State, msg: fig::SexpMessage) -> Erm<()> {
-        Ok(())
-    }
-    fn handle_binary(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut State, msg: fig::BinaryMessage) -> Erm<()> {
+    fn handle_binary(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut State, msg: &fig::BinaryMessage) -> Erm<()> {
         Ok(())
     }
     fn render(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut State) -> Erm<()> {
@@ -206,45 +162,78 @@ impl teleia::state::Game for Overlays {
             &glam::Vec3::new(0.0, 0.0, -1.0),
             &glam::Vec3::new(0.0, 1.0, 0.0),
         );
-        while let Some(msg) = self.state.fig.pump() {
-            let malformed = format!("malformed {} data: {}", msg.event, msg.data);
+        while let Some(msg) = self.state.fig_binary.pump()? {
             for ov in self.overlays.iter_mut() {
-                ov.handle(ctx, st, &mut self.state, msg.clone())?;
+                ov.handle_binary(ctx, st, &mut self.state, &msg)?;
             }
-            if msg.event == sexp!((avatar tracking)) {
-                if self.state.handle_tracking(msg).is_none() { log::warn!("{}", malformed) }
-            } else if msg.event == sexp!((avatar reset)) {
-                self.reset(ctx, st)?;
-            } else if msg.event == sexp!((avatar toggle)) {
-                if self.state.toggles.handle(ctx, st, msg).is_none() { log::warn!("{}", malformed) }
-            } else if msg.event == sexp!((avatar toggle set)) {
-                if self.state.toggles.handle_set(ctx, st, msg, true).is_none() { log::warn!("{}", malformed) }
-            } else if msg.event == sexp!((avatar toggle unset)) {
-                if self.state.toggles.handle_set(ctx, st, msg, false).is_none() { log::warn!("{}", malformed) }
-            } else if msg.event == sexp!((avatar overlay muzak)) {
-                if self.state.handle_overlay_muzak(msg).is_none() { log::warn!("{}", malformed) }
-            } else if msg.event == sexp!((avatar overlay muzak clear)) {
-                if self.state.handle_overlay_muzak_clear().is_none() { log::warn!("{}", malformed) }
-            } else if msg.event == sexp!((avatar overlay chat)) {
-                if self.state.handle_overlay_chat(msg).is_none() { log::warn!("{}", malformed) }
-            } else if msg.event == sexp!((avatar overlay cursor)) {
-                if self.state.handle_overlay_cursor(msg).is_none() { log::warn!("{}", malformed) }
-            }
-        }
-        while let Some(msg) = self.state.fig_binary.pump() {
             match &*msg.event {
-                b"background frame" => {
+                b"overlay reset" => self.reset(ctx, st)?,
+                b"overlay tracking" => {
+                    let res: Erm<()> = (|| {
+                        let mut reader = std::io::Cursor::new(&msg.data);
+                        let eye_left = reader.read_f32::<LE>()?;
+                        let eye_right = reader.read_f32::<LE>()?;
+                        let mouth = reader.read_f32::<LE>()?;
+                        let euler_x = reader.read_f32::<LE>()?.to_radians();
+                        let euler_y = PI - reader.read_f32::<LE>()?.to_radians();
+                        let euler_z = reader.read_f32::<LE>()?.to_radians() + PI/2.0;
+                        self.state.tracking.eyes = (eye_left, eye_right);
+                        self.state.tracking.mouth = mouth;
+                        self.state.tracking.neck = glam::Quat::from_euler(
+                            glam::EulerRot::XYZ, euler_x, euler_y, euler_z
+                        );
+                        Ok(())
+                    })();
+                    if let Err(e) = res { log::warn!("malformed tracking update: {}", e); }
+                },
+                b"overlay background frame" => {
                     if let Some(f) = background::Frame::parse(&mut &*msg.data) {
                         self.state.backgrounds.update(ctx, f);
                     } else {
-                        log::warn!("failed to parse frame");
+                        log::warn!("malformed background frame");
                     }
                 },
-                _ => {
-                    for ov in self.overlays.iter_mut() {
-                        ov.handle_binary(ctx, st, &mut self.state, msg.clone())?;
+                b"overlay toggle" => self.state.toggles.handle(ctx, st, msg),
+                b"overlay toggle set" => self.state.toggles.handle_set(ctx, st, msg, true),
+                b"overlay toggle unset" => self.state.toggles.handle_set(ctx, st, msg, false),
+                b"overlay info emacs" => {
+                    let mut reader = std::io::Cursor::new(&msg.data);
+                    match reader.read_i32::<LE>() {
+                        Ok(heartrate) => self.state.info.emacs_heartrate = heartrate,
+                        Err(e) => log::warn!("malformed Emacs update: {}", e),
                     }
                 },
+                b"overlay info emacs cursor" => {
+                    let res: Erm<()> = (|| {
+                        let mut reader = std::io::Cursor::new(&msg.data);
+                        let cursor_x = reader.read_f32::<LE>()?;
+                        let cursor_y = reader.read_f32::<LE>()?;
+                        self.state.info.emacs_cursor = (cursor_x, cursor_y);
+                        Ok(())
+                    })();
+                    if let Err(e) = res { log::warn!("malformed Emacs cursor update: {}", e); }
+                },
+                b"overlay info credits music" => match str::from_utf8(&msg.data) {
+                    Ok(nm) => self.state.info.muzak_author = Some(nm.to_owned()),
+                    Err(e) => log::warn!("malformed music credits update: {}", e),
+                },
+                b"overlay info credits music clear" => { self.state.info.muzak_author = None; },
+                b"overlay chat" => {
+                    let res: Erm<()> = (|| {
+                        let mut reader = std::io::Cursor::new(&msg.data);
+                        let author = fig::read_length_prefixed_utf8(&mut reader)?;
+                        let msg = fig::read_length_prefixed_utf8(&mut reader)?;
+                        let time = reader.read_f32::<LE>()?;
+                        let biblicality = reader.read_f32::<LE>()?;
+                        self.state.chat.author = author;
+                        self.state.chat.msg = msg;
+                        self.state.chat.time = time;
+                        self.state.chat.biblicality = biblicality;
+                        Ok(())
+                    })();
+                    if let Err(e) = res { log::warn!("malformed chat update: {}", e); }
+                },
+                _ => {},
             }
         }
         self.state.update(ctx, st)?;
diff --git a/crates/renderer/src/overlay/automata.rs b/crates/renderer/src/overlay/automata.rs
index 2677fcd..8354a4a 100644
--- a/crates/renderer/src/overlay/automata.rs
+++ b/crates/renderer/src/overlay/automata.rs
@@ -1,9 +1,8 @@
 use teleia::*;
 
 use glow::HasContext;
-use lexpr::sexp;
-use base64::prelude::*;
 use rand::Rng;
+use byteorder::{LE, ReadBytesExt};
 
 use crate::overlay;
 
@@ -237,26 +236,6 @@ impl Overlay {
             ctx.gl.generate_mipmap(glow::TEXTURE_2D);
         }
     }
-    pub fn handle_spawn(&mut self, msg: fig::SexpMessage) -> Option<()> {
-        let bs = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
-        let s = std::str::from_utf8(&bs).ok()?;
-        let bcol = BASE64_STANDARD.decode(msg.data.get(2)?.as_str()?).ok()?;
-        let scol = std::str::from_utf8(&bcol).ok()?.trim().strip_prefix("#")?;
-        let col = u32::from_str_radix(scol, 16).ok()?;
-        let r = (col >> 16 & 0xff) as u8;
-        let g = (col >> 8 & 0xff) as u8;
-        let b = (col & 0xff) as u8;
-        if let Some(pat) = Pattern::from_rle(s) {
-            let mut rng = rand::thread_rng();
-            let x = rng.gen_range(0..WIDTH);
-            let y = rng.gen_range(0..HEIGHT);
-            self.rules[self.next_rule] = CellRule { color: [r, g, b, 0xff] };
-            self.spawn(x as i32, y as i32, self.next_rule as u8, &pat);
-            self.next_rule = (self.next_rule + 1) % 256;
-            if self.next_rule == 0 { self.next_rule = 1; }
-        }
-        Some(())
-    }
 }
 impl overlay::Overlay for Overlay {
     fn reset(&mut self, ctx: &context::Context, st: &mut state::State, _ost: &mut overlay::State) -> Erm<()> {
@@ -268,13 +247,31 @@ impl overlay::Overlay for Overlay {
         }
         Ok(())
     }
-    fn handle(
+    fn handle_binary(
         &mut self, ctx: &context::Context, st: &mut state::State, _ost: &mut overlay::State,
-        msg: fig::SexpMessage,
+        msg: &fig::BinaryMessage,
     ) -> Erm<()> {
-        let malformed = format!("malformed {} data: {}", msg.event, msg.data);
-        if msg.event == sexp!((avatar automata spawn)) {
-            if self.handle_spawn(msg).is_none() { log::warn!("{}", malformed) }
+        if msg.event == b"overlay automata spawn" {
+            let res: Erm<()> = (|| {
+                let mut reader = std::io::Cursor::new(&msg.data);
+                let rle = fig::read_length_prefixed_utf8(&mut reader)?;
+                let _user = fig::read_length_prefixed_utf8(&mut reader)?;
+                let col = reader.read_u32::<LE>()?;
+                let r = (col >> 16 & 0xff) as u8;
+                let g = (col >> 8 & 0xff) as u8;
+                let b = (col & 0xff) as u8;
+                if let Some(pat) = Pattern::from_rle(&rle) {
+                    let mut rng = rand::thread_rng();
+                    let x = rng.gen_range(0..WIDTH);
+                    let y = rng.gen_range(0..HEIGHT);
+                    self.rules[self.next_rule] = CellRule { color: [r, g, b, 0xff] };
+                    self.spawn(x as i32, y as i32, self.next_rule as u8, &pat);
+                    self.next_rule = (self.next_rule + 1) % 256;
+                    if self.next_rule == 0 { self.next_rule = 1; }
+                }
+                Ok(())
+            })();
+            if let Err(e) = res { log::warn!("malformed automata spawn update: {}", e); }
         }
         Ok(())
     }
diff --git a/crates/renderer/src/overlay/irish.rs b/crates/renderer/src/overlay/irish.rs
deleted file mode 100644
index d2ee909..0000000
--- a/crates/renderer/src/overlay/irish.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use teleia::*;
-
-use lexpr::sexp;
-use base64::prelude::*;
-
-use crate::{fig, overlay};
-
-pub const WIDTH: f32 = 500.0;
-pub const HEIGHT: f32 = 700.0;
-
-pub struct Quote {
-    text: String,
-    start_time: u64,
-}
-
-pub struct Overlay {
-    fb: framebuffer::Framebuffer,
-    shader: shader::Shader,
-    font: font::TrueType,
-    quote: Option<Quote>,
-}
-
-impl Overlay {
-    pub fn new(ctx: &context::Context) -> Self {
-        Self {
-            fb: framebuffer::Framebuffer::new(ctx, &glam::Vec2::new(WIDTH, HEIGHT), &glam::Vec2::new(0.0, 0.0)),
-            shader: shader::Shader::new(ctx, include_str!("../assets/shaders/irish/vert.glsl"), include_str!("../assets/shaders/irish/frag.glsl")),
-            font: font::TrueType::new(ctx, 40.0, include_bytes!("../assets/fonts/HennyPenny-Regular.ttf")),
-            quote: None,
-        }
-    }
-    pub fn handle_start(
-        &mut self,
-        ctx: &context::Context, st: &state::State,
-        msg: fig::SexpMessage
-    ) -> Option<()> {
-        let bq = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
-        let quote = String::from_utf8_lossy(&bq);
-        self.quote = Some(Quote { text: quote.to_string(), start_time: st.tick });
-        Some(())
-    }
-    pub fn handle_update(
-        &mut self,
-        ctx: &context::Context, st: &state::State,
-        msg: fig::SexpMessage
-    ) -> Option<()> {
-        let bq = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
-        let quote = String::from_utf8_lossy(&bq);
-        if let Some(q) = &mut self.quote {
-            q.text = quote.to_string();
-        }
-        Some(())
-    }
-    pub fn handle_save(
-        &mut self,
-        ctx: &context::Context, st: &state::State,
-        msg: fig::SexpMessage
-    ) -> Option<()> {
-        let bq = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
-        let path = String::from_utf8_lossy(&bq);
-        let mut buf = vec![0; (WIDTH * HEIGHT * 4.0) as usize];
-        self.fb.get_pixels_raw(ctx, &mut buf);
-        let img = image::RgbaImage::from_raw(WIDTH as u32, HEIGHT as u32, buf)?;
-        img.save_with_format(path.to_string(), image::ImageFormat::Png).ok()?;
-        Some(())
-    }
-}
-
-impl overlay::Overlay for Overlay {
-    fn reset(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut overlay::State) -> Erm<()> {
-        self.quote = None;
-        Ok(())
-    }
-    fn handle(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut overlay::State, msg: fig::SexpMessage) -> Erm<()> {
-        let malformed = format!("malformed {} data: {}", msg.event, msg.data);
-        if msg.event == sexp!((overlay irish start)) {
-            if self.handle_start(ctx, st, msg).is_none() { log::warn!("{}", malformed) }
-        } else if msg.event == sexp!((overlay irish update)) {
-            if self.handle_update(ctx, st, msg).is_none() { log::warn!("{}", malformed) }
-        } else if msg.event == sexp!((overlay irish save)) {
-            if self.handle_save(ctx, st, msg).is_none() { log::warn!("{}", malformed) }
-        }
-        Ok(())
-    }
-    fn render(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut overlay::State) -> Erm<()> {
-        if let Some(q) = &self.quote {
-            st.bind_framebuffer(ctx, &self.fb);
-            ctx.clear();
-            st.bind_2d(ctx, &ost.assets.shader_flat);
-            ost.backgrounds.drawing.bind(ctx);
-            ost.assets.shader_flat.set_f32(ctx, "transparency", 0.0);
-            ost.assets.shader_flat.set_mat4(ctx, "view", &glam::Mat4::IDENTITY);
-            ost.assets.shader_flat.set_mat4(ctx, "position", &glam::Mat4::IDENTITY);
-            st.mesh_square.render(ctx);
-            self.font.render_text_helper(ctx, st,
-                &glam::Vec2::new(0.0, 0.0),
-                &glam::Vec2::new(21.0, 40.0),
-                &q.text,
-                &[]
-            );
-            st.bind_render_framebuffer(ctx);
-            st.bind_2d(ctx, &self.shader);
-            self.fb.bind_texture(ctx);
-            self.shader.set_position_2d(
-                ctx, st,
-                &glam::Vec2::new(1000.0, 200.0),
-                &glam::Vec2::new(WIDTH, HEIGHT)
-            );
-            st.mesh_square.render(ctx);
-        }
-        Ok(())
-    }
-}
diff --git a/crates/renderer/src/overlay/model.rs b/crates/renderer/src/overlay/model.rs
index 9714f09..d74870e 100644
--- a/crates/renderer/src/overlay/model.rs
+++ b/crates/renderer/src/overlay/model.rs
@@ -2,8 +2,6 @@ use teleia::*;
 use termion::raw::IntoRawMode;
 
 use std::f32::consts::PI;
-use lexpr::sexp;
-use base64::prelude::*;
 
 use crate::{overlay, terminal};
 
@@ -72,13 +70,6 @@ impl Overlay {
             ),
         }
     }
-    pub fn handle_text(&mut self, msg: fig::SexpMessage) -> Option<()> {
-        let bs = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
-        let s = std::str::from_utf8(&bs).ok()?;
-        log::info!("handle_text: {}", s);
-        self.terminal.fill_string(s);
-        Some(())
-    }
     fn render_model(&mut self, ctx: &context::Context, st: &mut state::State) -> Option<()> {
         // self.model_fb.blit(
         //     ctx, &st.render_framebuffer,
@@ -90,10 +81,12 @@ impl Overlay {
 }
 
 impl overlay::Overlay for Overlay {
-    fn handle(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut overlay::State, msg: fig::SexpMessage) -> Erm<()> {
-        let malformed = format!("malformed {} data: {}", msg.event, msg.data);
-        if msg.event == sexp!((avatar text)) {
-            if self.handle_text(msg).is_none() { log::warn!("{}", malformed) }
+    fn handle_binary(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut overlay::State, msg: &fig::BinaryMessage) -> Erm<()> {
+        if msg.event == b"overlay avatar text" {
+            match str::from_utf8(&msg.data) {
+                Ok(s) => self.terminal.fill_string(s),
+                Err(e) => log::warn!("malformed avatar text update: {}", e),
+            }
         }
         Ok(())
     }
diff --git a/crates/renderer/src/overlay/shader.rs b/crates/renderer/src/overlay/shader.rs
index 379cfd8..2bed8d6 100644
--- a/crates/renderer/src/overlay/shader.rs
+++ b/crates/renderer/src/overlay/shader.rs
@@ -1,9 +1,6 @@
 use teleia::*;
 
-use lexpr::sexp;
-use base64::prelude::*;
-
-use crate::{fig, overlay, toggle};
+use crate::{overlay, toggle};
 
 pub struct Overlay {
     visualizer: newton_shader::Visualizer,
@@ -16,22 +13,6 @@ impl Overlay {
             visualizer,
         }
     }
-    pub fn handle_overlay_shader(
-        &mut self,
-        ctx: &context::Context, st: &state::State,
-        msg: fig::SexpMessage
-    ) -> Option<()> {
-        let ba = BASE64_STANDARD.decode(msg.data.get(0)?.as_str()?).ok()?;
-        let author = String::from_utf8_lossy(&ba);
-        let bs = BASE64_STANDARD.decode(msg.data.get(1)?.as_str()?).ok()?;
-        let s = String::from_utf8_lossy(&bs);
-        self.visualizer.author = author.to_string();
-        if let Err(e) = self.visualizer.set(ctx, st, &s) {
-            log::warn!("error compiling shader: {}", e);
-            self.visualizer.shader = None;
-        }
-        Some(())
-    }
 }
 
 impl overlay::Overlay for Overlay {
@@ -40,10 +21,20 @@ impl overlay::Overlay for Overlay {
         self.visualizer.shader = None;
         Ok(())
     }
-    fn handle(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut overlay::State, msg: fig::SexpMessage) -> Erm<()> {
-        if msg.event == sexp!((avatar overlay shader)) {
-            let malformed = format!("malformed {} data: {}", msg.event, msg.data);
-            if self.handle_overlay_shader(ctx, st, msg).is_none() { log::warn!("{}", malformed) }
+    fn handle_binary(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut overlay::State, msg: &fig::BinaryMessage) -> Erm<()> {
+        if msg.event == b"overlay shader" {
+            let res: Erm<()> = (|| {
+                let mut reader = std::io::Cursor::new(&msg.data);
+                let author = fig::read_length_prefixed_utf8(&mut reader)?;
+                let shader = fig::read_length_prefixed_utf8(&mut reader)?;
+                self.visualizer.author = author.to_string();
+                if let Err(e) = self.visualizer.set(ctx, st, &shader) {
+                    log::warn!("error compiling shader: {}", e);
+                    self.visualizer.shader = None;
+                }
+                Ok(())
+            })();
+            if let Err(e) = res { log::warn!("malformed shader update: {}", e); }
         }
         Ok(())
     }
@@ -63,15 +54,14 @@ impl overlay::Overlay for Overlay {
             s.set_vec2(ctx, "resolution", &glam::Vec2::new(ctx.render_width, ctx.render_height));
             let elapsed = (st.tick - self.visualizer.tickset) as f32 / 60.0;
             s.set_f32(ctx, "time", elapsed);
-            s.set_f32(ctx, "chat_time", (ost.chat.time - self.visualizer.timeset) as f32);
+            s.set_f32(ctx, "chat_time", ost.chat.time - self.visualizer.timeset as f32);
             ctx.render_no_geometry();
-            s.set_f32(ctx, "tracking_mouth", ost.tracking_mouth);
-            // log::info!("eyes: {:?}", self.tracking_eyes);
-            s.set_vec2(ctx, "tracking_eyes", &glam::Vec2::new(ost.tracking_eyes.0, ost.tracking_eyes.1));
-            s.set_mat4(ctx, "tracking_neck", &glam::Mat4::from_quat(ost.tracking_neck));
-            s.set_vec2(ctx, "emacs_cursor", &glam::Vec2::new(ost.emacs_cursor.0, ost.emacs_cursor.1));
-            s.set_vec2(ctx, "mouse_cursor", &glam::Vec2::new(ost.mouse_cursor.0, ost.mouse_cursor.1));
-            s.set_i32(ctx, "heartrate", ost.emacs_heartrate);
+            s.set_f32(ctx, "tracking_mouth", ost.tracking.mouth);
+            s.set_vec2(ctx, "tracking_eyes", &glam::Vec2::new(ost.tracking.eyes.0, ost.tracking.eyes.1));
+            s.set_mat4(ctx, "tracking_neck", &glam::Mat4::from_quat(ost.tracking.neck));
+            s.set_vec2(ctx, "emacs_cursor", &glam::Vec2::new(ost.info.emacs_cursor.0, ost.info.emacs_cursor.1));
+            s.set_vec2(ctx, "mouse_cursor", &glam::Vec2::new(ost.info.mouse_cursor.0, ost.info.mouse_cursor.1));
+            s.set_i32(ctx, "heartrate", ost.info.emacs_heartrate);
         }
         if let Some(t@toggle::Toggle { val: true, .. }) = ost.toggles.get(ctx, st, "adblock") {
             st.bind_2d(ctx, &ost.assets.shader_flat);
@@ -89,7 +79,7 @@ impl overlay::Overlay for Overlay {
         if let Some(_) = &self.visualizer.shader {
             authors.push(format!("shader by {}", self.visualizer.author));
         }
-        if let Some(a) = &ost.muzak_author {
+        if let Some(a) = &ost.info.muzak_author {
             authors.push(format!("music by {}", a));
         }
         let astr: String = authors.join(", ");
diff --git a/crates/renderer/src/overlay/tcg.rs b/crates/renderer/src/overlay/tcg.rs
index 1ec74ca..5c6c16a 100644
--- a/crates/renderer/src/overlay/tcg.rs
+++ b/crates/renderer/src/overlay/tcg.rs
@@ -2,7 +2,7 @@ use teleia::*;
 use image::EncodableLayout;
 use glow::HasContext;
 
-use crate::{fig, overlay};
+use crate::overlay;
 
 pub const WIDTH: f32 = 320.0;
 pub const HEIGHT: f32 = 450.0;
@@ -64,60 +64,62 @@ impl overlay::Overlay for Overlay {
     fn reset(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut overlay::State) -> Erm<()> {
         Ok(())
     }
-    fn handle_binary(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut overlay::State, msg: fig::BinaryMessage) -> Erm<()> {
+    fn handle_binary(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut overlay::State, msg: &fig::BinaryMessage) -> Erm<()> {
         match &*msg.event {
             b"overlay tcg generate" => {
-                let s = std::str::from_utf8(&msg.data)?.to_owned();
-                let mut sp = s.split("\t");
-                let id = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                let name = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                let ty = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                let depicted_subject = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                let element = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                let color = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                log::info!("{} {} {}", &color[1..=2], &color[3..=4], &color[5..=6]);
-                let r = i64::from_str_radix(&color[1..=2], 16)?;
-                let g = i64::from_str_radix(&color[3..=4], 16)?;
-                let b = i64::from_str_radix(&color[5..=6], 16)?;
-                let faction = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                let equity = sp.next().ok_or(Error::NotEnoughFields)?.parse()?;
-                let boost_level = sp.next().ok_or(Error::NotEnoughFields)?.parse()?;
-                let rarity = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                let rarity_level = sp.next().ok_or(Error::NotEnoughFields)?.parse()?;
-                let body_text = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                let base_image_name = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                let flags = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
-                unsafe {
-                    let img = image::ImageReader::open(format!("crates/renderer/src/assets/textures/tcg/bases/{}.png", base_image_name))?.decode()?.into_rgba8();
-                    self.texture.bind(ctx);
-                    ctx.gl.tex_image_2d(
-                        glow::TEXTURE_2D,
-                        0,
-                        glow::RGBA as i32,
-                        img.width() as i32,
-                        img.height() as i32,
-                        0,
-                        glow::RGBA,
-                        glow::UNSIGNED_BYTE,
-                        Some(&img.as_bytes()),
-                    );
-                    ctx.gl.generate_mipmap(glow::TEXTURE_2D);
-                }
-                self.card = Some(Card {
-                    name,
-                    ty,
-                    depicted_subject,
-                    element,
-                    color: glam::Vec4::new(r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0),
-                    faction,
-                    equity,
-                    boost_level,
-                    rarity,
-                    rarity_level,
-                    body_text,
-                    base_image_name,
-                    flags,
-                });
+                let res: Erm<()> = (|| {
+                    let s = std::str::from_utf8(&msg.data)?.to_owned();
+                    let mut sp = s.split("\t");
+                    let id = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    let name = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    let ty = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    let depicted_subject = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    let element = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    let color = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    let r = i64::from_str_radix(&color[1..=2], 16)?;
+                    let g = i64::from_str_radix(&color[3..=4], 16)?;
+                    let b = i64::from_str_radix(&color[5..=6], 16)?;
+                    let faction = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    let equity = sp.next().ok_or(Error::NotEnoughFields)?.parse()?;
+                    let boost_level = sp.next().ok_or(Error::NotEnoughFields)?.parse()?;
+                    let rarity = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    let rarity_level = sp.next().ok_or(Error::NotEnoughFields)?.parse()?;
+                    let body_text = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    let base_image_name = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    let flags = sp.next().ok_or(Error::NotEnoughFields)?.to_owned();
+                    unsafe {
+                        let img = image::ImageReader::open(format!("crates/renderer/src/assets/textures/tcg/bases/{}.png", base_image_name))?.decode()?.into_rgba8();
+                        self.texture.bind(ctx);
+                        ctx.gl.tex_image_2d(
+                            glow::TEXTURE_2D,
+                            0,
+                            glow::RGBA as i32,
+                            img.width() as i32,
+                            img.height() as i32,
+                            0,
+                            glow::RGBA,
+                            glow::UNSIGNED_BYTE,
+                            Some(&img.as_bytes()),
+                        );
+                        ctx.gl.generate_mipmap(glow::TEXTURE_2D);
+                    }
+                    self.card = Some(Card {
+                        name,
+                        ty,
+                        depicted_subject,
+                        element,
+                        color: glam::Vec4::new(r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0),
+                        faction,
+                        equity,
+                        boost_level,
+                        rarity, rarity_level,
+                        body_text,
+                        base_image_name,
+                        flags,
+                    });
+                    Ok(())
+                })();
+                if let Err(e) = res { log::warn!("malformed TCG generate: {}", e); }
             },
             _ => {},
         }
diff --git a/crates/renderer/src/toggle.rs b/crates/renderer/src/toggle.rs
index f6d60a4..8468fc4 100644
--- a/crates/renderer/src/toggle.rs
+++ b/crates/renderer/src/toggle.rs
@@ -1,8 +1,6 @@
 use teleia::*;
 use std::collections::HashMap;
 
-use crate::fig;
-
 #[derive(Debug, Clone)]
 pub struct Toggle {
     pub val: bool,
@@ -27,15 +25,25 @@ impl Toggles {
     pub fn reset(&mut self) {
         self.toggles.clear();
     }
-    pub fn handle(&mut self, ctx: &context::Context, st: &state::State, msg: fig::SexpMessage) -> Option<()> {
-        let nm = msg.data.get(0)?.as_str()?;
+    pub fn handle(&mut self,
+        ctx: &context::Context, st: &state::State,
+        msg: fig::BinaryMessage
+    ) {
+        let nm = if let Ok(s) = str::from_utf8(&msg.data) { s } else {
+            log::warn!("failed to decode toggle name");
+            return;
+        };
         let prev = self.get(ctx, st, nm).map(|t| t.val).unwrap_or(false);
         self.set(ctx, st, nm, !prev);
-        Some(())
     }
-    pub fn handle_set(&mut self, ctx: &context::Context, st: &state::State, msg: fig::SexpMessage, val: bool) -> Option<()> {
-        let nm = msg.data.get(0)?.as_str()?;
+    pub fn handle_set(&mut self,
+        ctx: &context::Context, st: &state::State,
+        msg: fig::BinaryMessage, val: bool
+    ) {
+        let nm = if let Ok(s) = str::from_utf8(&msg.data) { s } else {
+            log::warn!("failed to decode toggle name");
+            return;
+        };
         self.set(ctx, st, nm, val);
-        Some(())
     }
 }