2019-05-24 17:25:03 +00:00
|
|
|
//! Ruffle web frontend.
|
2019-05-03 02:11:47 +00:00
|
|
|
mod audio;
|
|
|
|
mod render;
|
|
|
|
|
|
|
|
use crate::{audio::WebAudioBackend, render::WebCanvasRenderBackend};
|
2019-05-10 16:06:47 +00:00
|
|
|
use generational_arena::{Arena, Index};
|
2019-04-28 01:15:43 +00:00
|
|
|
use js_sys::Uint8Array;
|
2019-05-17 02:14:23 +00:00
|
|
|
use std::{cell::RefCell, error::Error, num::NonZeroI32};
|
2019-08-09 21:50:20 +00:00
|
|
|
use wasm_bindgen::{prelude::*, JsCast, JsValue};
|
|
|
|
use web_sys::{Event, EventTarget, HtmlCanvasElement};
|
2019-04-28 01:15:43 +00:00
|
|
|
|
2019-05-03 00:17:02 +00:00
|
|
|
thread_local! {
|
2019-05-24 17:25:03 +00:00
|
|
|
/// We store the actual instances of the ruffle core in a static pool.
|
|
|
|
/// This gives us a clear boundary between the JS side and Rust side, avoiding
|
|
|
|
/// issues with lifetimes and type paramters (which cannot be exported with wasm-bindgen).
|
|
|
|
static INSTANCES: RefCell<Arena<RuffleInstance>> = RefCell::new(Arena::new());
|
2019-05-17 02:14:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type AnimationHandler = Closure<FnMut(f64)>;
|
|
|
|
|
2019-05-24 17:25:03 +00:00
|
|
|
struct RuffleInstance {
|
2019-08-10 05:34:15 +00:00
|
|
|
core: ruffle_core::Player<WebAudioBackend, WebCanvasRenderBackend>,
|
2019-05-17 02:14:23 +00:00
|
|
|
timestamp: f64,
|
|
|
|
animation_handler: Option<AnimationHandler>, // requestAnimationFrame callback
|
|
|
|
animation_handler_id: Option<NonZeroI32>, // requestAnimationFrame id
|
2019-08-09 21:50:20 +00:00
|
|
|
#[allow(dead_code)]
|
|
|
|
click_callback: Option<Closure<FnMut(Event)>>,
|
2019-05-03 00:17:02 +00:00
|
|
|
}
|
|
|
|
|
2019-05-24 17:25:03 +00:00
|
|
|
/// An opaque handle to a `RuffleInstance` inside the pool.
|
|
|
|
///
|
|
|
|
/// This type is exported to JS, and is used to interact with the library.
|
2019-04-28 01:15:43 +00:00
|
|
|
#[wasm_bindgen]
|
2019-05-17 02:14:23 +00:00
|
|
|
#[derive(Clone)]
|
2019-05-24 17:25:03 +00:00
|
|
|
pub struct Ruffle(Index);
|
2019-04-28 01:15:43 +00:00
|
|
|
|
|
|
|
#[wasm_bindgen]
|
2019-05-24 17:25:03 +00:00
|
|
|
impl Ruffle {
|
|
|
|
pub fn new(canvas: HtmlCanvasElement, swf_data: Uint8Array) -> Result<Ruffle, JsValue> {
|
|
|
|
Ruffle::new_internal(canvas, swf_data).map_err(|_| "Error creating player".into())
|
2019-04-28 01:15:43 +00:00
|
|
|
}
|
|
|
|
|
2019-05-17 02:14:23 +00:00
|
|
|
pub fn destroy(&mut self) -> Result<(), JsValue> {
|
|
|
|
// Remove instance from the active list.
|
2019-05-24 17:25:03 +00:00
|
|
|
if let Some(instance) = INSTANCES.with(|instances| {
|
|
|
|
let mut instances = instances.borrow_mut();
|
|
|
|
instances.remove(self.0)
|
2019-05-17 02:14:23 +00:00
|
|
|
}) {
|
|
|
|
// Cancel the animation handler, if it's still active.
|
2019-05-24 17:25:03 +00:00
|
|
|
if let Some(id) = instance.animation_handler_id {
|
2019-05-17 02:14:23 +00:00
|
|
|
if let Some(window) = web_sys::window() {
|
|
|
|
return window.cancel_animation_frame(id.into());
|
|
|
|
}
|
2019-05-06 10:51:09 +00:00
|
|
|
}
|
2019-05-17 02:14:23 +00:00
|
|
|
}
|
2019-05-06 10:51:09 +00:00
|
|
|
|
2019-05-17 02:14:23 +00:00
|
|
|
// Player is dropped at this point.
|
|
|
|
Ok(())
|
2019-04-28 01:15:43 +00:00
|
|
|
}
|
|
|
|
}
|
2019-04-28 06:08:59 +00:00
|
|
|
|
2019-05-24 17:25:03 +00:00
|
|
|
impl Ruffle {
|
|
|
|
fn new_internal(canvas: HtmlCanvasElement, swf_data: Uint8Array) -> Result<Ruffle, Box<Error>> {
|
2019-04-30 08:53:21 +00:00
|
|
|
console_error_panic_hook::set_once();
|
2019-05-06 10:51:09 +00:00
|
|
|
let _ = console_log::init_with_level(log::Level::Trace);
|
2019-04-30 08:53:21 +00:00
|
|
|
|
2019-04-28 06:08:59 +00:00
|
|
|
let mut data = vec![0; swf_data.length() as usize];
|
|
|
|
swf_data.copy_to(&mut data[..]);
|
|
|
|
|
2019-08-12 01:02:45 +00:00
|
|
|
let window = web_sys::window().ok_or_else(|| "Expected window")?;
|
2019-04-29 20:24:29 +00:00
|
|
|
let renderer = WebCanvasRenderBackend::new(&canvas)?;
|
2019-04-30 08:53:21 +00:00
|
|
|
let audio = WebAudioBackend::new()?;
|
2019-04-28 06:08:59 +00:00
|
|
|
|
2019-08-10 05:34:15 +00:00
|
|
|
let core = ruffle_core::Player::new(renderer, audio, data)?;
|
2019-04-29 20:24:29 +00:00
|
|
|
|
2019-08-12 01:02:45 +00:00
|
|
|
// let style = canvas.style();
|
|
|
|
// style
|
|
|
|
// .set_property("width", &format!("{}px", canvas_width))
|
|
|
|
// .map_err(|_| "Unable to set style")?;
|
|
|
|
// style
|
|
|
|
// .set_property("height", &format!("{}px", canvas_height))
|
|
|
|
// .map_err(|_| "Unable to set style")?;
|
2019-04-29 20:24:29 +00:00
|
|
|
|
2019-05-17 02:14:23 +00:00
|
|
|
let timestamp = window
|
|
|
|
.performance()
|
|
|
|
.ok_or_else(|| "Expected performance")?
|
|
|
|
.now();
|
|
|
|
|
|
|
|
// Create instance.
|
2019-05-24 17:25:03 +00:00
|
|
|
let instance = RuffleInstance {
|
2019-05-17 02:14:23 +00:00
|
|
|
core,
|
|
|
|
animation_handler: None,
|
|
|
|
animation_handler_id: None,
|
2019-08-09 21:50:20 +00:00
|
|
|
click_callback: None,
|
2019-05-17 02:14:23 +00:00
|
|
|
timestamp,
|
|
|
|
};
|
|
|
|
|
|
|
|
// Register the instance and create the animation frame closure.
|
2019-05-24 17:25:03 +00:00
|
|
|
let mut ruffle = INSTANCES.with(move |instances| {
|
|
|
|
let mut instances = instances.borrow_mut();
|
|
|
|
let index = instances.insert(instance);
|
|
|
|
let ruffle = Ruffle(index);
|
2019-05-17 02:14:23 +00:00
|
|
|
|
|
|
|
// Create the animation frame closure.
|
|
|
|
{
|
2019-05-24 17:25:03 +00:00
|
|
|
let mut ruffle = ruffle.clone();
|
|
|
|
let instance = instances.get_mut(index).unwrap();
|
2019-05-17 02:14:23 +00:00
|
|
|
instance.animation_handler = Some(Closure::wrap(Box::new(move |timestamp: f64| {
|
2019-05-24 17:25:03 +00:00
|
|
|
ruffle.tick(timestamp);
|
2019-05-17 02:14:23 +00:00
|
|
|
})
|
|
|
|
as Box<FnMut(f64)>));
|
|
|
|
}
|
|
|
|
|
2019-08-09 21:50:20 +00:00
|
|
|
// Create click event handler.
|
|
|
|
{
|
|
|
|
let click_callback = Closure::wrap(Box::new(move |_| {
|
|
|
|
INSTANCES.with(move |instances| {
|
|
|
|
let mut instances = instances.borrow_mut();
|
|
|
|
if let Some(instance) = instances.get_mut(index) {
|
|
|
|
instance.core.set_is_playing(true);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}) as Box<FnMut(Event)>);
|
|
|
|
let canvas_events: &EventTarget = canvas.as_ref();
|
|
|
|
canvas_events
|
|
|
|
.add_event_listener_with_callback(
|
|
|
|
"click",
|
|
|
|
click_callback.as_ref().unchecked_ref(),
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
canvas.style().set_property("cursor", "pointer").unwrap();
|
|
|
|
let instance = instances.get_mut(index).unwrap();
|
|
|
|
instance.click_callback = Some(click_callback);
|
|
|
|
|
|
|
|
// Do an initial render for the pause overlay.
|
|
|
|
instance.core.render();
|
|
|
|
}
|
|
|
|
|
2019-05-24 17:25:03 +00:00
|
|
|
ruffle
|
2019-05-03 00:17:02 +00:00
|
|
|
});
|
|
|
|
|
2019-05-17 02:14:23 +00:00
|
|
|
// Do an initial tick to start the animation loop.
|
2019-05-24 17:25:03 +00:00
|
|
|
ruffle.tick(timestamp);
|
2019-05-17 02:14:23 +00:00
|
|
|
|
2019-05-24 17:25:03 +00:00
|
|
|
Ok(ruffle)
|
2019-05-17 02:14:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn tick(&mut self, timestamp: f64) {
|
2019-05-24 17:25:03 +00:00
|
|
|
INSTANCES.with(|instances| {
|
|
|
|
let mut instances = instances.borrow_mut();
|
|
|
|
if let Some(instance) = instances.get_mut(self.0) {
|
|
|
|
let dt = timestamp - instance.timestamp;
|
|
|
|
instance.timestamp = timestamp;
|
2019-08-09 21:50:20 +00:00
|
|
|
|
2019-05-24 17:25:03 +00:00
|
|
|
instance.core.tick(dt);
|
2019-05-17 02:14:23 +00:00
|
|
|
|
|
|
|
// Request next animation frame.
|
2019-05-24 17:25:03 +00:00
|
|
|
if let Some(handler) = &instance.animation_handler {
|
2019-05-17 02:14:23 +00:00
|
|
|
let window = web_sys::window().unwrap();
|
|
|
|
let id = window
|
|
|
|
.request_animation_frame(handler.as_ref().unchecked_ref())
|
|
|
|
.unwrap();
|
2019-05-24 17:25:03 +00:00
|
|
|
instance.animation_handler_id = NonZeroI32::new(id);
|
2019-05-17 02:14:23 +00:00
|
|
|
} else {
|
2019-05-24 17:25:03 +00:00
|
|
|
instance.animation_handler_id = None;
|
2019-05-17 02:14:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2019-04-28 06:08:59 +00:00
|
|
|
}
|
|
|
|
}
|