diff options
Diffstat (limited to 'crates/renderer/src/overlay.rs')
| -rw-r--r-- | crates/renderer/src/overlay.rs | 250 |
1 files changed, 250 insertions, 0 deletions
diff --git a/crates/renderer/src/overlay.rs b/crates/renderer/src/overlay.rs new file mode 100644 index 0000000..fd59f82 --- /dev/null +++ b/crates/renderer/src/overlay.rs @@ -0,0 +1,250 @@ +pub mod model; +pub mod shader; +pub mod drawing; +pub mod automata; + +use teleia::*; + +use std::f32::consts::PI; +use lexpr::sexp; +use base64::prelude::*; + +use crate::{assets, fig, toggle, input, background}; + +pub struct Chat { + author: String, + msg: String, + time: f64, + biblicality: f32, +} +impl Chat { + pub fn new() -> Self { + Self { + author: format!(""), + msg: format!(""), + time: 0.0, + biblicality: 0.0, + } + } +} +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>, + chat: Chat, + toggles: toggle::Toggles, + input: input::Input, + backgrounds: background::Backgrounds, +} +impl State { + pub fn new(ctx: &context::Context) -> Self { + let model = scene::Scene::from_gltf(ctx, include_bytes!("assets/scenes/lcolonq.vrm")); + let model_neck_base = model.nodes_by_name.get("J_Bip_C_Neck") + .and_then(|i| model.nodes.get(*i)) + .expect("failed to find neck joint") + .transform; + Self { + 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)), + ]), + fig_binary: fig::BinaryClient::new("shiro:32051", false, &[ + b"background frame" + ]), + 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, + chat: Chat::new(), + toggles: toggle::Toggles::new(), + backgrounds: background::Backgrounds::new(ctx), + input: input::Input::new(), + } + } + 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, + &glam::Vec3::new(0.0, 0.0, 1.0), + &glam::Vec3::new(0.0, 0.0, -1.0), + &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); + while let Some(msg) = self.fig.pump() { + let malformed = format!("malformed {} data: {}", msg.event, msg.data); + if msg.event == sexp!((avatar tracking)) { + if self.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.toggles.handle(ctx, st, msg).is_none() { log::warn!("{}", malformed) } + } else if msg.event == sexp!((avatar toggle set)) { + if self.toggles.handle_set(ctx, st, msg, true).is_none() { log::warn!("{}", malformed) } + } else if msg.event == sexp!((avatar toggle unset)) { + if self.toggles.handle_set(ctx, st, msg, false).is_none() { log::warn!("{}", malformed) } + } else if msg.event == sexp!((avatar overlay muzak)) { + if self.handle_overlay_muzak(msg).is_none() { log::warn!("{}", malformed) } + } else if msg.event == sexp!((avatar overlay muzak clear)) { + if self.handle_overlay_muzak_clear().is_none() { log::warn!("{}", malformed) } + } else if msg.event == sexp!((avatar overlay chat)) { + if self.handle_overlay_chat(msg).is_none() { log::warn!("{}", malformed) } + } else if msg.event == sexp!((avatar overlay cursor)) { + if self.handle_overlay_cursor(msg).is_none() { log::warn!("{}", malformed) } + } else { + log::info!("received unhandled event {} with data: {}", msg.event, msg.data); + } + } + while let Some(msg) = self.fig_binary.pump() { + 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); + } + Ok(()) + } +} + +pub trait Overlay { + fn reset(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut State) -> Erm<()> { + Ok(()) + } + 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 render(&mut self, ctx: &context::Context, st: &mut state::State, ost: &mut State) -> Erm<()> { + Ok(()) + } +} + +pub struct Overlays { + state: State, + overlays: Vec<Box<dyn Overlay>> +} +impl Overlays { + pub fn new(ctx: &context::Context, overlays: Vec<Box<dyn Overlay>>) -> Self { + Self { + state: State::new(ctx), + overlays, + } + } + pub fn reset(&mut self, ctx: &context::Context, st: &mut state::State) -> Erm<()> { + self.state.reset(ctx, st); + for ov in self.overlays.iter_mut() { + ov.reset(ctx, st, &mut self.state)?; + } + Ok(()) + } +} +impl teleia::state::Game for Overlays { + fn update(&mut self, ctx: &context::Context, st: &mut state::State) -> Erm<()> { + st.move_camera( + ctx, + &glam::Vec3::new(0.0, 0.0, 1.0), + &glam::Vec3::new(0.0, 0.0, -1.0), + &glam::Vec3::new(0.0, 1.0, 0.0), + ); + self.state.reset(ctx, st); + for ov in self.overlays.iter_mut() { + ov.update(ctx, st, &mut self.state)?; + } + Ok(()) + } + fn render(&mut self, ctx: &context::Context, st: &mut state::State) -> Erm<()> { + ctx.clear_color(glam::Vec4::new(0.0, 0.0, 0.0, 0.0)); + ctx.clear(); + for ov in self.overlays.iter_mut() { + ov.render(ctx, st, &mut self.state)?; + } + Ok(()) + } +} |