Update

5 files changed, 108 insertions, 239 deletions

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); }
             },
             _ => {},
         }