@perspective-dev/viewer 4.0.0

package/src/rust/renderer/registry.rs

@@ -0,0 +1,135 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::thread::LocalKey;
+
+use extend::ext;
+use perspective_js::utils::global;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+use web_sys::*;
+
+use crate::js::plugin::*;
+
+thread_local! {
+    pub static PLUGIN_REGISTRY: Rc<RefCell<Vec<PluginRecord>>> = Rc::new(RefCell::new(vec![]));
+}
+
+pub struct PluginRecord {
+    name: String,
+    category: String,
+    tag_name: String,
+    priority: i32,
+}
+
+/// A global registry of all plugins that have been registered.
+#[ext]
+pub impl LocalKey<Rc<RefCell<Vec<PluginRecord>>>> {
+    fn create_plugins(&'static self) -> Vec<JsPerspectiveViewerPlugin> {
+        register_default();
+        self.with(
+            |plugins| -> Result<Vec<JsPerspectiveViewerPlugin>, JsValue> {
+                let mut elements = vec![];
+                for plugin in plugins.borrow().iter() {
+                    let element = create_plugin(&plugin.tag_name);
+                    let style = element.unchecked_ref::<HtmlElement>().style();
+                    style.set_property("position", "absolute")?;
+                    style.set_property("top", "0")?;
+                    style.set_property("right", "0")?;
+                    style.set_property("bottom", "0")?;
+                    style.set_property("left", "0")?;
+                    elements.push(element);
+                }
+
+                Ok(elements)
+            },
+        )
+        .unwrap()
+    }
+
+    fn default_plugin_name(&'static self) -> String {
+        register_default();
+        self.with(|plugins| {
+            plugins
+                .borrow()
+                .iter()
+                .map(|plugin| plugin.name.to_owned())
+                .next()
+                .unwrap()
+        })
+    }
+
+    fn available_plugin_names_by_category(&'static self) -> HashMap<String, Vec<String>> {
+        register_default();
+        self.with(|plugins| {
+            plugins.borrow().iter().fold(
+                HashMap::<String, Vec<String>>::default(),
+                |mut acc, plugin| {
+                    acc.entry(plugin.category.to_owned())
+                        .or_default()
+                        .push(plugin.name.to_owned());
+                    acc
+                },
+            )
+        })
+    }
+
+    fn register_plugin(&'static self, tag_name: &str) {
+        assert!(
+            !self.with(|plugin| plugin.borrow().iter().any(|n| n.tag_name == tag_name)),
+            "Plugin Custom Element '{tag_name}' already registered"
+        );
+
+        self.with(|plugin| {
+            let plugin_inst = create_plugin(tag_name);
+            let record = PluginRecord {
+                tag_name: tag_name.to_owned(),
+                name: plugin_inst.name(),
+                category: plugin_inst
+                    .category()
+                    .unwrap_or_else(|| "Custom".to_owned()),
+                priority: plugin_inst.priority().unwrap_or_default(),
+            };
+            let mut plugins = plugin.borrow_mut();
+            plugins.push(record);
+            plugins.sort_by(|a, b| Ord::cmp(&b.priority, &a.priority));
+        });
+    }
+
+    #[cfg(test)]
+    fn reset(&'static self) {
+        self.with(|plugins| plugins.borrow_mut().clear());
+    }
+}
+
+fn register_default() {
+    PLUGIN_REGISTRY.with(|plugins| {
+        if plugins.borrow().is_empty() {
+            plugins.borrow_mut().push(PluginRecord {
+                name: "Debug".to_owned(),
+                category: "Custom".to_owned(),
+                tag_name: "perspective-viewer-plugin".to_owned(),
+                priority: 0,
+            })
+        }
+    })
+}
+
+fn create_plugin(tag_name: &str) -> JsPerspectiveViewerPlugin {
+    global::document()
+        .create_element(tag_name)
+        .unwrap()
+        .unchecked_into()
+}

package/src/rust/renderer/render_timer.rs

@@ -0,0 +1,185 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use std::cell::RefCell;
+use std::collections::VecDeque;
+use std::future::Future;
+use std::rc::Rc;
+
+use perspective_js::utils::global;
+use serde::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+
+/// A utility struct to track and calculate framerate metrics.
+#[derive(Default, Clone)]
+pub struct MovingWindowRenderTimer(Rc<RefCell<RenderTimerType>>);
+
+enum RenderTimerType {
+    Moving(Closure<dyn Fn(JsValue)>, Rc<RefCell<RenderTimerState>>),
+    Constant(f64),
+}
+
+pub struct RenderTimerState {
+    render_times: VecDeque<f64>,
+    total_render_count: u32,
+    start_time: f64,
+}
+
+/// Serialization of snapshot stats for the JS API call.
+#[derive(Clone, Serialize)]
+pub struct RenderTimerStats {
+    render_times: VecDeque<f64>,
+    total_render_count: u32,
+    total_time: f64,
+    virtual_fps: f64,
+    actual_fps: f64,
+}
+
+impl MovingWindowRenderTimer {
+    pub async fn capture_time<T>(&self, f: impl Future<Output = T>) -> T {
+        let perf = global::window().performance().unwrap();
+        let start = match *self.0.borrow() {
+            RenderTimerType::Constant(_) => 0_f64,
+            RenderTimerType::Moving(..) => perf.now(),
+        };
+
+        let result = f.await;
+        match &mut *self.0.borrow_mut() {
+            RenderTimerType::Moving(_, timings) => {
+                let mut stats = timings.borrow_mut();
+                let now = perf.now();
+                stats.render_times.push_back(now - start);
+                if stats.render_times.len() > 5 {
+                    stats.render_times.pop_front();
+                }
+
+                stats.total_render_count += 1;
+            },
+            RenderTimerType::Constant(_) => (),
+        };
+
+        result
+    }
+
+    pub fn get_stats(&self) -> Option<RenderTimerStats> {
+        match &*self.0.borrow_mut() {
+            RenderTimerType::Constant(_) => None,
+            RenderTimerType::Moving(_, timings) => {
+                let perf = global::window().performance().unwrap();
+                let mut state = timings.borrow_mut();
+                let stats = (&*state).into();
+                state.total_render_count = 0;
+                state.start_time = perf.now();
+                Some(stats)
+            },
+        }
+    }
+
+    pub fn set_throttle(&mut self, val: Option<f64>) {
+        match val {
+            None => {
+                *self.0.borrow_mut() = RenderTimerType::default();
+            },
+            Some(val) => {
+                *self.0.borrow_mut() = RenderTimerType::Constant(val);
+            },
+        }
+    }
+
+    pub fn get_throttle(&self) -> i32 {
+        match &*self.0.borrow() {
+            RenderTimerType::Constant(constant) => *constant as i32,
+            RenderTimerType::Moving(_, timings) => {
+                let state = timings.borrow();
+                if state.render_times.len() < 5 {
+                    0_i32
+                } else {
+                    f64::min(5000_f64, state.virtual_fps()) as i32
+                }
+            },
+        }
+    }
+}
+
+impl Drop for RenderTimerType {
+    fn drop(&mut self) {
+        if let Self::Moving(closure, _) = self {
+            global::document()
+                .remove_event_listener_with_callback(
+                    "visibilitychange",
+                    closure.as_ref().unchecked_ref(),
+                )
+                .unwrap();
+        }
+    }
+}
+
+impl Default for RenderTimerType {
+    fn default() -> Self {
+        let state: Rc<RefCell<RenderTimerState>> = Default::default();
+        Self::Moving(state.register_on_visibility_change(), state)
+    }
+}
+
+impl RenderTimerState {
+    fn virtual_fps(&self) -> f64 {
+        let sum = self.render_times.iter().sum::<f64>();
+        let len = self.render_times.len() as f64;
+        sum / len
+    }
+}
+
+#[extend::ext]
+impl RefCell<RenderTimerState> {
+    /// We need to clear the throttle queue when the browser tab is hidden, else
+    /// the next frame timing will be the time the tab was hidden + render time.
+    fn register_on_visibility_change(self: &Rc<Self>) -> Closure<dyn Fn(JsValue)> {
+        let state = self.clone();
+        let closure = Closure::new(move |_| {
+            *state.borrow_mut() = Default::default();
+        });
+
+        global::document()
+            .add_event_listener_with_callback("visibilitychange", closure.as_ref().unchecked_ref())
+            .unwrap();
+
+        closure
+    }
+}
+
+impl Default for RenderTimerState {
+    fn default() -> Self {
+        let perf = global::window().performance().unwrap();
+        let start_time = perf.now();
+        Self {
+            render_times: Default::default(),
+            total_render_count: Default::default(),
+            start_time,
+        }
+    }
+}
+
+impl From<&RenderTimerState> for RenderTimerStats {
+    fn from(value: &RenderTimerState) -> Self {
+        let perf = global::window().performance().unwrap();
+        let now = perf.now();
+        let total_time = now - value.start_time;
+        RenderTimerStats {
+            render_times: value.render_times.clone(),
+            total_render_count: value.total_render_count,
+            total_time,
+            actual_fps: value.total_render_count as f64 / (total_time / 1000_f64),
+            virtual_fps: 1000_f64 / value.virtual_fps(),
+        }
+    }
+}