Fix font rendering, allow blocking bus client.HEADmaster

3 files changed, 52 insertions, 31 deletions

diff --git a/crates/teleia/src/assets/shaders/bitmap/frag.glsl b/crates/teleia/src/assets/shaders/bitmap/frag.glsl
index 30ee1c4..b79e8d0 100644
--- a/crates/teleia/src/assets/shaders/bitmap/frag.glsl
+++ b/crates/teleia/src/assets/shaders/bitmap/frag.glsl
@@ -10,9 +10,9 @@ out vec4 frag_color;
 
 void main() {
     vec4 texel = texture(texture_data, vertex_texcoord);
-    if (vertex_color == vec3(0.0, 0.0, 0.0)) {
-        discard;
-    }
+    // if (vertex_color == vec3(0.0, 0.0, 0.0)) {
+    //     discard;
+    // }
     if (texel.rgb == vec3(0.0, 0.0, 0.0)) {
         frag_color = background;
         return;
diff --git a/crates/teleia/src/font.rs b/crates/teleia/src/font.rs
index d069176..822705c 100644
--- a/crates/teleia/src/font.rs
+++ b/crates/teleia/src/font.rs
@@ -5,7 +5,6 @@ pub struct BitmapParams<'color> {
     pub color: &'color [glam::Vec3],
     pub scale: glam::Vec2,
     pub offset: glam::Vec2,
-    pub background: glam::Vec4,
 }
 impl<'color> Default for BitmapParams<'color> {
     fn default() -> Self {
@@ -13,7 +12,6 @@ impl<'color> Default for BitmapParams<'color> {
             color: &[],
             scale: glam::Vec2::ONE,
             offset: glam::Vec2::ZERO,
-            background: glam::Vec4::ZERO,
         }
     }
 }
@@ -171,7 +169,6 @@ impl Bitmap {
                 color,
                 scale: glam::Vec2::ONE,
                 offset: glam::Vec2::ZERO,
-                background: glam::Vec4::ZERO,
             }
         )
     }
@@ -189,7 +186,6 @@ impl Bitmap {
         params: BitmapParams,
     ) {
         st.bind_2d(ctx, &st.shader_text_bitmap);
-        st.shader_text_bitmap.set_vec4(ctx, "background", &params.background);
         let dims = glam::Vec2::new(self.char_width as f32, self.char_height as f32);
         let fpos = pos + glam::Vec2::new(-dims.x / 2.0, dims.y / 2.0);
         st.shader_text_bitmap.set_position_text_bitmap(ctx, st, self, &fpos);
diff --git a/crates/teleia/src/net/fig.rs b/crates/teleia/src/net/fig.rs
index 0d5e16d..d49e498 100644
--- a/crates/teleia/src/net/fig.rs
+++ b/crates/teleia/src/net/fig.rs
@@ -50,7 +50,6 @@ impl BinaryClient {
         self.out_buf.write_u32::<byteorder::LE>(buf.len() as u32).wrap_err("failed to send message")?;
         self.out_buf.write_all(buf).wrap_err("failed to send message")?;
         Ok(())
-        
     }
     pub fn publish(&mut self, ev: &[u8], data: &[u8]) -> Erm<()> {
         write!(self.out_buf, "p").wrap_err("failed to send publish message to bus")?;
@@ -58,7 +57,7 @@ impl BinaryClient {
         self.write_length_prefixed(data)?;
         Ok(())
     }
-    fn pop_incoming_message(&mut self) -> Option<BinaryMessage> {
+    pub fn pop_incoming_message(&mut self) -> Option<BinaryMessage> {
         let mut reader = std::io::Cursor::new(&self.in_buf);
         let event_len = reader.read_u32::<byteorder::LE>().ok()?;
         let mut event = vec![0; event_len as usize];
@@ -70,31 +69,57 @@ impl BinaryClient {
         self.in_buf.drain(..len);
         Some(BinaryMessage { event, data })
     }
-    pub fn pump(&mut self) -> Erm<Option<BinaryMessage>> {
-        let mut events = polling::Events::new();
-        events.clear();
-        self.poller.wait(&mut events, Some(std::time::Duration::from_secs(0)))
-            .wrap_err("failed to poll message bus")?;
+    fn try_read(&mut self) -> Erm<()> {
+        let mut buf = [0; 1024];
+        match self.socket.read(&mut buf) {
+            Ok(sz) => self.in_buf.extend_from_slice(&buf[..sz]),
+            Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {},
+            e => { e.wrap_err("failed to read from bus socket")?; },
+        }
+        Ok(())
+    }
+    fn try_write(&mut self) -> Erm<()> {
+        if !self.out_buf.is_empty() {
+            match self.socket.write(&self.out_buf) {
+                Ok(sz) => { self.out_buf.drain(..sz); },
+                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {},
+                e => { e.wrap_err("failed to write to bus socket")?; },
+            }
+        }
+        Ok(())
+    }
+    fn resubscribe(&mut self) -> Erm<()> {
+        self.poller.modify(&self.socket, polling::Event::readable(KEY)).wrap_err("failed to update event to poll")?;
+        if !self.out_buf.is_empty() {
+            self.poller.modify(&self.socket, polling::Event::writable(KEY)).wrap_err("failed to update event to poll")?;
+        }
+        Ok(())
+    }
+    fn process_events(&mut self, events: &mut polling::Events) -> Erm<()> {
         for ev in events.iter() {
             if ev.key == KEY {
-                if ev.readable {
-                    let mut buf = [0; 1024];
-                    match self.socket.read(&mut buf) {
-                        Ok(sz) => self.in_buf.extend_from_slice(&buf[..sz]),
-                        Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {},
-                        e => { e.wrap_err("failed to read from bus socket")?; },
-                    }
-                }
-                if ev.writable && !self.out_buf.is_empty() {
-                    match self.socket.write(&self.out_buf) {
-                        Ok(sz) => { self.out_buf.drain(..sz); },
-                        Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {},
-                        e => { e.wrap_err("failed to write to bus socket")?; },
-                    }
-                }
-                self.poller.modify(&self.socket, polling::Event::all(KEY)).wrap_err("failed to update event to poll")?;
+                if ev.readable { self.try_read()?; }
+                if ev.writable { self.try_write()?; }
             }
         }
-        Ok(self.pop_incoming_message())
+        Ok(())
+    }
+    pub fn pump(&mut self) -> Erm<()> {
+        let mut events = polling::Events::new();
+        events.clear();
+        self.resubscribe()?;
+        self.poller.wait(&mut events, Some(std::time::Duration::from_secs(0)))
+            .wrap_err("failed to poll message bus")?;
+        self.process_events(&mut events)?;
+        Ok(())
+    }
+    pub fn wait(&mut self) -> Erm<()> {
+        let mut events = polling::Events::new();
+        events.clear();
+        self.resubscribe()?;
+        self.poller.wait(&mut events, None)
+            .wrap_err("failed to poll message bus")?;
+        self.process_events(&mut events)?;
+        Ok(())
     }
 }