WIP

7 files changed, 133 insertions, 39 deletions

diff --git a/crates/renderer/src/assets/shaders/background/frag.glsl b/crates/renderer/src/assets/shaders/background/frag.glsl
new file mode 100644
index 0000000..73a166d
--- /dev/null
+++ b/crates/renderer/src/assets/shaders/background/frag.glsl
@@ -0,0 +1,13 @@
+uniform sampler2D texture_data;
+uniform sampler2D background;
+
+void main()
+{
+    vec2 tcfull = vec2(vertex_texcoord.x, 1.0 - vertex_texcoord.y);
+    vec4 texel = texture(texture_data, tcfull);
+    if (texel.r == 0.0) {
+        discard;
+    }
+    // frag_color = vec4(1.0, 1.0, 1.0, 1.0);
+    frag_color = vec4(texture(background, tcfull).xyz, 1.0);
+}
diff --git a/crates/renderer/src/assets/shaders/background/vert.glsl b/crates/renderer/src/assets/shaders/background/vert.glsl
new file mode 100644
index 0000000..33e176c
--- /dev/null
+++ b/crates/renderer/src/assets/shaders/background/vert.glsl
@@ -0,0 +1,4 @@
+void main()
+{
+    default_main();
+}
diff --git a/crates/renderer/src/assets/textures/everest.jpg b/crates/renderer/src/assets/textures/everest.jpg
new file mode 100644
index 0000000..eb911d0
--- /dev/null
+++ b/crates/renderer/src/assets/textures/everest.jpg
diff --git a/crates/renderer/src/background.rs b/crates/renderer/src/background.rs
new file mode 100644
index 0000000..cf99fc9
--- /dev/null
+++ b/crates/renderer/src/background.rs
@@ -0,0 +1,62 @@
+use teleia::*;
+
+use byteorder::ReadBytesExt;
+
+use glow::HasContext;
+
+pub struct Frame<'a> {
+    tag: &'a [u8],
+    width: u32,
+    height: u32,
+    pixels: &'a [u8],
+}
+impl<'a> Frame<'a> {
+    fn read_length_prefixed(reader: &mut &'a [u8]) -> Option<&'a [u8]> {
+        let len = reader.read_u32::<byteorder::LE>().ok()? as usize;
+        log::info!("len: {}", len);
+        let (x, xs) = reader.split_at(len);
+        *reader = xs;
+        Some(x)
+    }
+    pub fn parse(reader: &mut &'a [u8]) -> Option<Self> {
+        log::info!("message: {:?}", reader);
+        let tag = Self::read_length_prefixed(reader)?;
+        log::info!("tag: {:?}", tag);
+        let width = reader.read_u32::<byteorder::LE>().ok()?;
+        log::info!("width: {:?}", width);
+        let height = reader.read_u32::<byteorder::LE>().ok()?;
+        log::info!("height: {:?}", height);
+        let pixels = *reader;
+        Some(Self { tag, width, height, pixels })
+    }
+}
+
+pub struct Backgrounds {
+    pub drawing: texture::Texture,
+}
+impl Backgrounds {
+    pub fn new(ctx: &context::Context) -> Self {
+        Self {
+            // drawing: texture::Texture::new_empty(ctx), 
+            drawing: texture::Texture::new(ctx, include_bytes!("assets/textures/everest.jpg")), 
+        }
+    }
+    pub fn update<'a>(&self, ctx: &context::Context, f: Frame<'a>) {
+        unsafe {
+            let err = ctx.gl.get_error();
+            self.drawing.bind(ctx);
+            ctx.gl.tex_image_2d(
+                glow::TEXTURE_2D,
+                0,
+                glow::RGBA as i32,
+                f.width as i32,
+                f.height as i32,
+                0,
+                glow::RGBA,
+                glow::UNSIGNED_BYTE,
+                Some(&f.pixels),
+            );
+            ctx.gl.generate_mipmap(glow::TEXTURE_2D);
+        }
+    }
+}
diff --git a/crates/renderer/src/fig.rs b/crates/renderer/src/fig.rs
index 8023f01..a696a9a 100644
--- a/crates/renderer/src/fig.rs
+++ b/crates/renderer/src/fig.rs
@@ -99,11 +99,11 @@ impl BinaryClient {
         mut state: BinaryClientState,
     ) -> BinaryClientState {
         loop {
-            let new_state = match state {
+            state = match state {
                 BinaryClientState::PartialEventLength { mut buf_len, mut buf } => {
                     buf_len += if let Some(x) = Self::read(reader, &mut buf[buf_len..]) {
                         x
-                    } else { break; };
+                    } else { break BinaryClientState::PartialEventLength { buf_len, buf }; };
                     if buf_len == 4 {
                         let len = u32::from_le_bytes(buf) as usize;
                         BinaryClientState::PartialEvent {
@@ -111,28 +111,24 @@ impl BinaryClient {
                             buf_len: 0,
                             buf: vec![0; len],
                         }
-                    } else {
-                        BinaryClientState::PartialEventLength { buf_len, buf }
-                    }
+                    } else { BinaryClientState::PartialEventLength { buf_len, buf } }
                 },
                 BinaryClientState::PartialEvent { len, mut buf_len, mut buf } => {
                     buf_len += if let Some(x) = Self::read(reader, &mut buf[buf_len..]) {
                         x
-                    } else { break; };
+                    } else { break BinaryClientState::PartialEvent { len, buf_len, buf }; };
                     if buf_len == len {
                         BinaryClientState::PartialDataLength {
                             event: buf.clone(),
                             buf_len: 0,
                             buf: [0; 4],
                         }
-                    } else {
-                        BinaryClientState::PartialEvent { len, buf_len, buf }
-                    }
+                    } else { BinaryClientState::PartialEvent { len, buf_len, buf } }
                 },
                 BinaryClientState::PartialDataLength { event, mut buf_len, mut buf } => {
                     buf_len += if let Some(x) = Self::read(reader, &mut buf[buf_len..]) {
                         x
-                    } else { break; };
+                    } else { break BinaryClientState::PartialDataLength { event, buf_len, buf }; };
                     if buf_len == 4 {
                         let len = u32::from_le_bytes(buf) as usize;
                         BinaryClientState::PartialData {
@@ -141,41 +137,37 @@ impl BinaryClient {
                             buf_len: 0,
                             buf: vec![0; len],
                         }
-                    } else {
-                        BinaryClientState::PartialDataLength { event, buf_len, buf }
-                    }
+                    } else { BinaryClientState::PartialDataLength { event, buf_len, buf } }
                 },
                 BinaryClientState::PartialData { event, len, mut buf_len, mut buf } => {
                     buf_len += if let Some(x) = Self::read(reader, &mut buf[buf_len..]) {
                         x
-                    } else { break; };
+                    } else { break BinaryClientState::PartialData { event, len, buf_len, buf }; };
                     if buf_len == len {
                         BinaryClientState::Message {
                             event,
                             data: buf.clone(),
                         }
-                    } else {
-                        BinaryClientState::PartialData { event, len, buf_len, buf }
-                    }
+                    } else { BinaryClientState::PartialData { event, len, buf_len, buf } }
                 },
-                BinaryClientState::Message{..} => break,
+                st@BinaryClientState::Message{..} => break st,
             };
-            state = new_state;
-        };
-        state
+        }
     }
     pub fn pump(&mut self) -> Option<BinaryMessage> {
-        None
-        // loop {
-        //     if let Some(new) = self.update_state(mem::take(&mut self.state)) {
-        //         self.state = new;
-        //     } else { break; }
-        // }
-        // if let BinaryClientState::Message { event, data } = self.state.clone() {
-        //     self.state = BinaryClientState::PartialEventLength { buf_len: 0, buf: [0; 4] };
-        //     Some(BinaryMessage { event, data })
-        // } else {
-        //     None
-        // }
+        self.state = Self::update_state(&mut self.reader, std::mem::take(&mut self.state));
+        match std::mem::take(&mut self.state) {
+            BinaryClientState::Message { event, data } => {
+                self.state = BinaryClientState::PartialEventLength { buf_len: 0, buf: [0; 4] };
+                Some(BinaryMessage {
+                    event: event,
+                    data: data,
+                })
+            },
+            st => {
+                self.state = st;
+                None
+            }
+        }
     }
 }
diff --git a/crates/renderer/src/main.rs b/crates/renderer/src/main.rs
index 24ecf8a..4aa1804 100644
--- a/crates/renderer/src/main.rs
+++ b/crates/renderer/src/main.rs
@@ -2,6 +2,7 @@
 mod assets;
 mod terminal;
 mod fig;
+mod background;
 mod toggle;
 mod overlay;
 
diff --git a/crates/renderer/src/overlay/shader.rs b/crates/renderer/src/overlay/shader.rs
index 181ba07..97e4d92 100644
--- a/crates/renderer/src/overlay/shader.rs
+++ b/crates/renderer/src/overlay/shader.rs
@@ -7,7 +7,7 @@ use device_query::DeviceQuery;
 
 use glow::HasContext;
 
-use crate::{assets, fig, toggle};
+use crate::{assets, fig, toggle, background};
 
 pub struct Chat {
     author: String,
@@ -38,9 +38,16 @@ pub struct Drawing {
     pixels: [u8; DRAWING_WIDTH * DRAWING_HEIGHT],
     last_point: Option<(i32, i32)>,
     shader_white: shader::Shader,
+    shader_background: shader::Shader,
 }
 impl Drawing {
     pub fn new(ctx: &context::Context) -> Self {
+        let shader_background = shader::Shader::new(
+            ctx,
+            include_str!("../assets/shaders/background/vert.glsl"),
+            include_str!("../assets/shaders/background/frag.glsl"),
+        );
+        shader_background.set_i32(ctx, "background", 1);
         Self {
             tex: texture::Texture::new_empty(ctx),
             pixels: [0; DRAWING_WIDTH * DRAWING_HEIGHT],
@@ -50,10 +57,11 @@ impl Drawing {
                 include_str!("../assets/shaders/white/vert.glsl"),
                 include_str!("../assets/shaders/white/frag.glsl"),
             ),
+            shader_background,
         }
     }
     pub fn coord(&self, x: usize, y: usize) -> Option<usize> {
-        if x > DRAWING_WIDTH || y > DRAWING_HEIGHT {
+        if x >= DRAWING_WIDTH || y >= DRAWING_HEIGHT {
             None
         } else {
             Some(x + y * DRAWING_WIDTH)
@@ -126,6 +134,7 @@ pub struct Overlay {
     muzak_author: Option<String>,
     chat: Chat,
     toggles: toggle::Toggles,
+    backgrounds: background::Backgrounds,
     drawing: Drawing,
     device: device_query::DeviceState,
 }
@@ -158,7 +167,7 @@ impl Overlay {
                 sexp!((avatar overlay emacs)),
             ]),
             fig_binary: fig::BinaryClient::new("shiro:32051", &[
-                b"test event"
+                b"background frame"
             ]),
             tracking_eyes: (1.0, 1.0),
             tracking_mouth: 0.0,
@@ -170,6 +179,7 @@ impl Overlay {
             muzak_author: None,
             chat: Chat::new(),
             toggles: toggle::Toggles::new(),
+            backgrounds: background::Backgrounds::new(ctx),
             drawing: Drawing::new(ctx),
             device: device_query::DeviceState::new(),
         }
@@ -257,9 +267,10 @@ impl Overlay {
         Some(())
     }
     pub fn render_drawing(&self, ctx: &context::Context, st: &mut state::State) {
-        st.bind_2d(ctx, &self.drawing.shader_white);
+        st.bind_2d(ctx, &self.drawing.shader_background);
         self.drawing.tex.bind(ctx);
-        self.drawing.shader_white.set_position_2d(
+        self.backgrounds.drawing.bind_index(ctx, 1);
+        self.drawing.shader_background.set_position_2d(
             ctx,
             &glam::Vec2::new(0.0, 0.0),
             &glam::Vec2::new(1920.0, 1080.0)
@@ -311,7 +322,18 @@ impl teleia::state::Game for Overlay {
             }
         }
         while let Some(msg) = self.fig_binary.pump() {
-            log::info!("binary message: {:?}", msg);
+            match &*msg.event {
+                b"background frame" => {
+                    if let Some(f) = background::Frame::parse(&mut &*msg.data) {
+                        self.backgrounds.update(ctx, f);
+                    } else {
+                        log::warn!("failed to parse frame");
+                    }
+                },
+                ev => {
+                    log::info!("unhandled event: {:?}", ev);
+                },
+            }
         }
         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);