feat(ui): add a dirty callback for ui updates in js

crates/core/src/play/mod.rs

@@ -17,7 +17,9 @@ use crate::{
 use btreemultimap::{BTreeMultiMap, MultiRange};
 use std::collections::HashSet;
 
-#[derive(Debug, Default, Clone)]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen::prelude::wasm_bindgen)]
+#[derive(Debug, Default, Clone, Copy)]
+#[repr(C)]
 pub struct JudgementReport {
     pub amazings: u32,
     pub perfects: u32,
@@ -28,9 +30,9 @@ pub struct JudgementReport {
 }
 
 pub struct Play<S: PlayState> {
-    field: Field,
-    state: S,
-    settings: Settings,
+    pub field: Field,
+    pub state: S,
+    pub settings: Settings,
 }
 
 impl<S: PlayState> Play<S> {
@@ -51,6 +53,13 @@ pub struct Active {
     judgement_report: JudgementReport,
 }
 
+impl Active {
+    #[must_use]
+    pub fn judgement_report(&self) -> &JudgementReport {
+        &self.judgement_report
+    }
+}
+
 pub struct Concluded {
     turntable: Turntable<turntable::Loaded>,
     actions: BTreeMultiMap<RuntimeNote, NoteAction>,

crates/head-wasm/Cargo.toml

@@ -22,12 +22,14 @@ release = ["rrr-head/release", "rrr-head/web"]
 
 [dependencies]
 anyhow = "1.0.65"
+js-sys = "0.3.60"
 log = { version = "0.4.17" }
 rrr-head = { path = "../head", default-features = false }
 console_error_panic_hook = "0.1.7"
 console_log = { version = "0.2.0", features = ["color"] }
 wasm-bindgen = "0.2.83"
 wasm-bindgen-futures = "0.4.33"
+winit = { version = "0.27.3", default-features = false }
 
 [dependencies.web-sys]
 version = "0.3.60"

crates/head-wasm/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"

crates/head-wasm/src/lib.rs

@@ -1,34 +1,131 @@
-use anyhow::Error;
-use rrr_head::prelude::winit::{
+#![feature(cfg_eval)]
+#![feature(type_alias_impl_trait)]
+
+use anyhow::{Error, Result};
+use js_sys::Function;
+use rrr_head::prelude::play;
+use rrr_head::{platform::platform::time::Time, query};
+use std::rc::Rc;
+use wasm_bindgen::{prelude::*, JsCast};
+use winit::error::OsError;
+
+#[cfg_attr(feature = "wasm-bindgen", wasm_bindgen)]
+use winit::{
     self,
     dpi::PhysicalSize,
     event_loop::EventLoop,
     platform::web::WindowBuilderExtWebSys,
     window::{Window, WindowBuilder},
 };
-use rrr_head::{platform::platform::time::Time, query};
-use std::rc::Rc;
-use wasm_bindgen::{closure::Closure, prelude::wasm_bindgen, JsCast};
+
 use web_sys::HtmlCanvasElement;
 
-pub fn build_window(
-    event_loop: &EventLoop<()>,
-    canvas: Option<HtmlCanvasElement>,
-    size: PhysicalSize<u32>,
-) -> Result<winit::window::Window, winit::error::OsError> {
-    {
-        log::debug!("Inner Size {:?}", size);
-        WindowBuilder::new()
+#[cfg_eval]
+#[cfg_attr(feature = "wasm-bindgen", wasm_bindgen)]
+pub struct Engine {
+    #[cfg_attr(feature = "wasm-bindgen", wasm_bindgen(skip))]
+    event_loop: EventLoop<()>,
+    window: Window,
+}
+
+#[wasm_bindgen]
+impl Engine {
+    #[inline]
+    pub(crate) fn new(engine: EngineComponents) -> Result<Engine> {
+        Self::init(engine)
+    }
+
+    fn init(engine: EngineComponents) -> Result<Self> {
+        let event_loop = EventLoop::new();
+
+        let size = PhysicalSize {
+            width: engine.width,
+            height: engine.height,
+        };
+        let window = WindowBuilder::new()
             .with_title("Rust Rust Revolution")
-            .with_canvas(canvas)
+            .with_canvas(engine.canvas)
             .with_inner_size(size)
             .with_resizable(false)
             .with_max_inner_size(size)
             .with_min_inner_size(size)
-            .build(event_loop)
+            .build(&event_loop)?;
+
+        Ok(Engine { event_loop, window })
     }
 }
 
+#[derive(Debug, Default, Clone)]
+#[wasm_bindgen]
+pub struct EngineBuilder {
+    pub(crate) engine: EngineComponents,
+}
+
+/// Components to use when building an Engine instance.
+#[derive(Debug, Clone)]
+pub(crate) struct EngineComponents {
+    pub canvas: Option<HtmlCanvasElement>,
+    pub width: u32,
+    pub height: u32,
+    pub ui_callback: Option<Function>,
+}
+
+impl Default for EngineComponents {
+    #[inline]
+    fn default() -> EngineComponents {
+        EngineComponents {
+            canvas: None,
+            width: 512,
+            height: 768,
+            ui_callback: None,
+        }
+    }
+}
+
+impl EngineBuilder {
+    /// Initializes builder with default values.
+    #[inline]
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    #[inline]
+    pub fn with_canvas(mut self, canvas: HtmlCanvasElement) -> Self {
+        self.engine.canvas.replace(canvas);
+        self
+    }
+
+    #[inline]
+    pub fn with_judgement_callback(mut self, callback: Function) -> Self {
+        self.engine.ui_callback.replace(callback);
+        self
+    }
+
+    #[inline]
+    pub fn build(self) -> Engine {
+        if let Ok(engine) = Engine::new(self.engine) {
+            engine
+        } else {
+            panic!("no good")
+        }
+    }
+}
+
+pub fn build_window(
+    event_loop: &EventLoop<()>,
+    canvas: Option<HtmlCanvasElement>,
+    size: PhysicalSize<u32>,
+) -> Result<Window, OsError> {
+    WindowBuilder::new()
+        .with_title("Rust Rust Revolution")
+        .with_canvas(canvas)
+        .with_inner_size(size)
+        .with_resizable(false)
+        .with_max_inner_size(size)
+        .with_min_inner_size(size)
+        .build(event_loop)
+}
+
 #[wasm_bindgen(start)]
 pub fn initialize() {
     console_log::init().unwrap();
@@ -48,7 +145,7 @@ pub fn play(canvas: Option<HtmlCanvasElement>, width: u32, height: u32) {
             let mut game = rrr_head::Game::<Time>::new(None, width, height);
             game.with_settings(extracted_settings);
 
-            rrr_head::run_game_loop(window, size, event_loop, game).await;
+            let _ = rrr_head::run_game_loop(window, size, event_loop, game).await;
         }
     });
 }
@@ -104,8 +201,6 @@ async fn initialize_window(
 }
 
 pub fn register_on_visibility_change_listener(window: &web_sys::Window) {
-    use wasm_bindgen::JsCast;
-
     let closure = Closure::wrap(Box::new(move || {
         let window = web_sys::window().unwrap();
         let document = window.document().unwrap();

crates/head/src/engine.rs

@@ -0,0 +1,26 @@
+/// Metadata Fetcher
+/// 
+///     Fetches data from a stream, therefore must be polled to come to completion.
+/// 
+
+/// Metadata Container
+/// 
+///     Holds metadata such as Charts, Songs, Playlists, Scores, Player Data, etc...
+/// 
+
+/// Chart Simulator
+/// 
+///     The engine is polled with a delta and progresses audio views and/or note views.
+/// 
+
+/// Web Head
+/// 
+///     Initializes the Metadata Container, Metadata Fetcher, and Chart Simulator as needed.
+///     Has platform specific requirements for interfacing with each of these libraries.
+/// 
+
+/// Native Head
+/// 
+///     Initializes the Metadata Container, Metadata Fetcher, and Chart Simulator as needed.
+///     Has platform specific requirements for interfacing with each of these libraries.
+/// 

crates/head/src/lib.rs

@@ -24,10 +24,19 @@ use winit::{
     window::WindowBuilder,
 };
 
+#[cfg_attr(
+    target_arch = "wasm32",
+    wasm_bindgen::prelude::wasm_bindgen(module = "\\/src\\/judgement.js")
+)]
+extern "C" {
+    fn update_judgement(judgement_report: play::JudgementReport);
+}
+
 pub mod prelude {
     pub use anyhow;
     pub use futures;
     pub use log;
+    pub use rrr_core::play;
     pub use winit;
 }
 
@@ -446,6 +455,10 @@ where
                         self.screen_height,
                     );
                 }
+
+                unsafe {
+                    update_judgement(*play.state.judgement_report());
+                }
             }
         }
     }

web/index.html

@@ -78,6 +78,7 @@
     </div>
     <script type="module">
         import init, { play, Engine, SettingsMerge } from "./bin/rrr.js";
+
         async function run() {
             await init();
 

web/src/judgement.js

@@ -0,0 +1,3 @@
+export function update_judgement(report) {
+    console.log("Perfects: ", report.perfects);
+}