2019-08-26 23:38:37 +00:00
|
|
|
use crate::avm1::Avm1;
|
2019-09-17 03:37:11 +00:00
|
|
|
use crate::backend::{
|
|
|
|
audio::AudioBackend, navigator::NavigatorBackend, render::Letterbox, render::RenderBackend,
|
|
|
|
};
|
2019-08-26 23:38:37 +00:00
|
|
|
use crate::events::{ButtonEvent, PlayerEvent};
|
|
|
|
use crate::library::Library;
|
|
|
|
use crate::movie_clip::MovieClip;
|
|
|
|
use crate::prelude::*;
|
|
|
|
use crate::transform::TransformStack;
|
|
|
|
use gc_arena::{make_arena, ArenaParameters, Collect, GcCell, MutationContext};
|
|
|
|
use log::info;
|
2019-09-17 03:37:11 +00:00
|
|
|
use rand::{rngs::SmallRng, SeedableRng};
|
2019-08-26 23:38:37 +00:00
|
|
|
use std::sync::Arc;
|
|
|
|
|
2019-10-08 04:02:09 +00:00
|
|
|
static DEVICE_FONT_TAG: &[u8] = include_bytes!("../assets/noto-sans-definefont3.bin");
|
|
|
|
|
2019-10-09 00:07:00 +00:00
|
|
|
/// The newest known Flash Player version, serves as a default to
|
|
|
|
/// `player_version`.
|
2019-10-09 23:46:15 +00:00
|
|
|
pub const NEWEST_PLAYER_VERSION: u8 = 32;
|
2019-10-09 00:07:00 +00:00
|
|
|
|
2019-08-26 23:38:37 +00:00
|
|
|
#[derive(Collect)]
|
|
|
|
#[collect(empty_drop)]
|
|
|
|
struct GcRoot<'gc> {
|
|
|
|
library: GcCell<'gc, Library<'gc>>,
|
|
|
|
root: DisplayNode<'gc>,
|
|
|
|
mouse_hover_node: GcCell<'gc, Option<DisplayNode<'gc>>>, // TODO: Remove GcCell wrapped inside GcCell.
|
2019-08-26 22:53:50 +00:00
|
|
|
avm: GcCell<'gc, Avm1<'gc>>,
|
2019-08-26 23:38:37 +00:00
|
|
|
}
|
|
|
|
|
2019-10-08 04:02:09 +00:00
|
|
|
type Error = Box<dyn std::error::Error>;
|
|
|
|
|
2019-08-26 23:38:37 +00:00
|
|
|
make_arena!(GcArena, GcRoot);
|
|
|
|
|
2019-09-01 19:24:04 +00:00
|
|
|
pub struct Player<Audio: AudioBackend, Renderer: RenderBackend, Navigator: NavigatorBackend> {
|
2019-10-09 00:07:00 +00:00
|
|
|
/// The version of the player we're emulating.
|
|
|
|
///
|
|
|
|
/// This serves a few purposes, primarily for compatibility:
|
|
|
|
///
|
|
|
|
/// * ActionScript can query the player version, ostensibly for graceful
|
|
|
|
/// degradation on older platforms. Certain SWF files broke with the
|
|
|
|
/// release of Flash Player 10 because the version string contains two
|
|
|
|
/// digits. This allows the user to play those old files.
|
|
|
|
/// * Player-specific behavior that was not properly versioned in Flash
|
|
|
|
/// Player can be enabled by setting a particular player version.
|
|
|
|
player_version: u8,
|
|
|
|
|
2019-08-26 23:38:37 +00:00
|
|
|
swf_data: Arc<Vec<u8>>,
|
|
|
|
swf_version: u8,
|
|
|
|
|
|
|
|
is_playing: bool,
|
|
|
|
|
|
|
|
audio: Audio,
|
|
|
|
renderer: Renderer,
|
2019-09-01 19:24:04 +00:00
|
|
|
navigator: Navigator,
|
2019-08-26 23:38:37 +00:00
|
|
|
transform_stack: TransformStack,
|
|
|
|
view_matrix: Matrix,
|
|
|
|
inverse_view_matrix: Matrix,
|
|
|
|
|
2019-09-02 03:03:50 +00:00
|
|
|
rng: SmallRng,
|
|
|
|
|
2019-08-26 23:38:37 +00:00
|
|
|
gc_arena: GcArena,
|
|
|
|
background_color: Color,
|
|
|
|
|
|
|
|
frame_rate: f64,
|
|
|
|
frame_accumulator: f64,
|
|
|
|
global_time: u64,
|
|
|
|
|
|
|
|
viewport_width: u32,
|
|
|
|
viewport_height: u32,
|
|
|
|
movie_width: u32,
|
|
|
|
movie_height: u32,
|
|
|
|
letterbox: Letterbox,
|
|
|
|
|
|
|
|
mouse_pos: (Twips, Twips),
|
|
|
|
is_mouse_down: bool,
|
|
|
|
}
|
|
|
|
|
2019-09-17 03:37:11 +00:00
|
|
|
impl<Audio: AudioBackend, Renderer: RenderBackend, Navigator: NavigatorBackend>
|
|
|
|
Player<Audio, Renderer, Navigator>
|
|
|
|
{
|
2019-08-26 23:38:37 +00:00
|
|
|
pub fn new(
|
2019-10-08 04:02:09 +00:00
|
|
|
mut renderer: Renderer,
|
2019-08-26 23:38:37 +00:00
|
|
|
audio: Audio,
|
2019-09-01 19:24:04 +00:00
|
|
|
navigator: Navigator,
|
2019-08-26 23:38:37 +00:00
|
|
|
swf_data: Vec<u8>,
|
2019-10-08 04:02:09 +00:00
|
|
|
) -> Result<Self, Error> {
|
2019-10-10 20:07:07 +00:00
|
|
|
let swf_stream = swf::read::read_swf_header(&swf_data[..]).unwrap();
|
|
|
|
let header = swf_stream.header;
|
|
|
|
let mut reader = swf_stream.reader;
|
|
|
|
|
2019-10-12 06:02:20 +00:00
|
|
|
// Decompress the entire SWF in memory.
|
2019-10-10 20:07:07 +00:00
|
|
|
// Sometimes SWFs will have an incorrectly compressed stream,
|
|
|
|
// but will otherwise decompress fine up to the End tag.
|
|
|
|
// So just warn on this case and try to continue gracefully.
|
2019-10-12 06:02:20 +00:00
|
|
|
let data = if header.compression == swf::Compression::Lzma {
|
|
|
|
// TODO: The LZMA decoder is still funky.
|
|
|
|
// It always errors, and doesn't return all the data if you use read_to_end,
|
|
|
|
// but read_exact at least returns the data... why?
|
|
|
|
// Does the decoder need to be flushed somehow?
|
|
|
|
let mut data = vec![0u8; swf_stream.uncompressed_length];
|
|
|
|
let _ = reader.get_mut().read_exact(&mut data);
|
|
|
|
data
|
|
|
|
} else {
|
|
|
|
let mut data = Vec::with_capacity(swf_stream.uncompressed_length);
|
|
|
|
if let Err(e) = reader.get_mut().read_to_end(&mut data) {
|
|
|
|
log::error!("Error decompressing SWF, may be corrupt: {}", e);
|
|
|
|
}
|
|
|
|
data
|
|
|
|
};
|
2019-10-10 20:07:07 +00:00
|
|
|
|
2019-08-26 23:38:37 +00:00
|
|
|
let swf_len = data.len();
|
|
|
|
|
|
|
|
info!("{}x{}", header.stage_size.x_max, header.stage_size.y_max);
|
|
|
|
|
|
|
|
let movie_width = (header.stage_size.x_max - header.stage_size.x_min).to_pixels() as u32;
|
|
|
|
let movie_height = (header.stage_size.y_max - header.stage_size.y_min).to_pixels() as u32;
|
|
|
|
|
2019-10-08 04:02:09 +00:00
|
|
|
// Load and parse the device font.
|
|
|
|
// TODO: We could use lazy_static here.
|
|
|
|
let device_font = Self::load_device_font(DEVICE_FONT_TAG, &mut renderer)
|
|
|
|
.expect("Unable to load device font");
|
2019-08-26 23:38:37 +00:00
|
|
|
let mut player = Player {
|
2019-10-09 00:07:00 +00:00
|
|
|
player_version: NEWEST_PLAYER_VERSION,
|
|
|
|
|
2019-08-26 23:38:37 +00:00
|
|
|
swf_data: Arc::new(data),
|
|
|
|
swf_version: header.version,
|
|
|
|
|
|
|
|
is_playing: false,
|
|
|
|
|
|
|
|
renderer,
|
|
|
|
audio,
|
2019-09-01 19:24:04 +00:00
|
|
|
navigator,
|
2019-08-26 23:38:37 +00:00
|
|
|
|
|
|
|
background_color: Color {
|
|
|
|
r: 255,
|
|
|
|
g: 255,
|
|
|
|
b: 255,
|
|
|
|
a: 255,
|
|
|
|
},
|
|
|
|
transform_stack: TransformStack::new(),
|
|
|
|
view_matrix: Default::default(),
|
|
|
|
inverse_view_matrix: Default::default(),
|
|
|
|
|
2019-09-02 03:03:50 +00:00
|
|
|
rng: SmallRng::from_seed([0u8; 16]), // TODO(Herschel): Get a proper seed on all platforms.
|
|
|
|
|
2019-08-26 23:38:37 +00:00
|
|
|
gc_arena: GcArena::new(ArenaParameters::default(), |gc_context| GcRoot {
|
2019-10-08 04:02:09 +00:00
|
|
|
library: GcCell::allocate(gc_context, Library::new(device_font)),
|
2019-08-26 23:38:37 +00:00
|
|
|
root: GcCell::allocate(
|
|
|
|
gc_context,
|
|
|
|
Box::new(MovieClip::new_with_data(
|
2019-10-09 23:46:15 +00:00
|
|
|
header.version,
|
2019-08-26 23:38:37 +00:00
|
|
|
gc_context,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
swf_len,
|
|
|
|
header.num_frames,
|
|
|
|
)),
|
|
|
|
),
|
|
|
|
mouse_hover_node: GcCell::allocate(gc_context, None),
|
2019-09-15 19:25:34 +00:00
|
|
|
avm: GcCell::allocate(gc_context, Avm1::new(gc_context)),
|
2019-08-26 23:38:37 +00:00
|
|
|
}),
|
|
|
|
|
|
|
|
frame_rate: header.frame_rate.into(),
|
|
|
|
frame_accumulator: 0.0,
|
|
|
|
global_time: 0,
|
|
|
|
|
|
|
|
movie_width,
|
|
|
|
movie_height,
|
|
|
|
viewport_width: movie_width,
|
|
|
|
viewport_height: movie_height,
|
|
|
|
letterbox: Letterbox::None,
|
|
|
|
|
|
|
|
mouse_pos: (Twips::new(0), Twips::new(0)),
|
|
|
|
is_mouse_down: false,
|
|
|
|
};
|
|
|
|
|
2019-10-07 08:36:05 +00:00
|
|
|
player.gc_arena.mutate(|gc_context, gc_root| {
|
|
|
|
gc_root
|
|
|
|
.root
|
|
|
|
.write(gc_context)
|
|
|
|
.post_instantiation(gc_context, gc_root.root)
|
|
|
|
});
|
|
|
|
|
2019-08-26 23:38:37 +00:00
|
|
|
player.build_matrices();
|
|
|
|
player.preload();
|
|
|
|
|
|
|
|
Ok(player)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn tick(&mut self, dt: f64) {
|
|
|
|
// Don't run until preloading is complete.
|
|
|
|
// TODO: Eventually we want to stream content similar to the Flash player.
|
|
|
|
if !self.audio.is_loading_complete() {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if self.is_playing() {
|
|
|
|
self.frame_accumulator += dt;
|
|
|
|
self.global_time += dt as u64;
|
|
|
|
let frame_time = 1000.0 / self.frame_rate;
|
|
|
|
|
|
|
|
let needs_render = self.frame_accumulator >= frame_time;
|
|
|
|
|
|
|
|
const MAX_FRAMES_PER_TICK: u32 = 5; // Sanity cap on frame tick.
|
|
|
|
let mut frame = 0;
|
|
|
|
while frame < MAX_FRAMES_PER_TICK && self.frame_accumulator >= frame_time {
|
|
|
|
self.frame_accumulator -= frame_time;
|
|
|
|
self.run_frame();
|
|
|
|
frame += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sanity: If we had too many frames to tick, just reset the accumulator
|
|
|
|
// to prevent running at turbo speed.
|
|
|
|
if self.frame_accumulator >= frame_time {
|
|
|
|
self.frame_accumulator = 0.0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if needs_render {
|
|
|
|
self.render();
|
|
|
|
}
|
|
|
|
|
|
|
|
self.audio.tick();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn is_playing(&self) -> bool {
|
|
|
|
self.is_playing
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn set_is_playing(&mut self, v: bool) {
|
|
|
|
if v {
|
|
|
|
// Allow auto-play after user gesture for web backends.
|
|
|
|
self.audio.prime_audio();
|
|
|
|
}
|
|
|
|
self.is_playing = v;
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn movie_width(&self) -> u32 {
|
|
|
|
self.movie_width
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn movie_height(&self) -> u32 {
|
|
|
|
self.movie_height
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn viewport_dimensions(&self) -> (u32, u32) {
|
|
|
|
(self.viewport_width, self.viewport_height)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn set_viewport_dimensions(&mut self, width: u32, height: u32) {
|
|
|
|
self.viewport_width = width;
|
|
|
|
self.viewport_height = height;
|
|
|
|
self.build_matrices();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn handle_event(&mut self, event: PlayerEvent) {
|
|
|
|
let mut needs_render = false;
|
2019-10-09 00:07:00 +00:00
|
|
|
let player_version = self.player_version;
|
2019-08-26 23:38:37 +00:00
|
|
|
|
|
|
|
// Update mouse position from mouse events.
|
|
|
|
if let PlayerEvent::MouseMove { x, y }
|
|
|
|
| PlayerEvent::MouseDown { x, y }
|
|
|
|
| PlayerEvent::MouseUp { x, y } = event
|
|
|
|
{
|
|
|
|
self.mouse_pos =
|
|
|
|
self.inverse_view_matrix * (Twips::from_pixels(x), Twips::from_pixels(y));
|
|
|
|
if self.update_roll_over() {
|
|
|
|
needs_render = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-17 03:37:11 +00:00
|
|
|
let (
|
|
|
|
global_time,
|
|
|
|
swf_data,
|
|
|
|
swf_version,
|
|
|
|
background_color,
|
|
|
|
renderer,
|
|
|
|
audio,
|
|
|
|
navigator,
|
|
|
|
rng,
|
|
|
|
is_mouse_down,
|
|
|
|
) = (
|
2019-08-26 23:38:37 +00:00
|
|
|
self.global_time,
|
|
|
|
&mut self.swf_data,
|
|
|
|
self.swf_version,
|
|
|
|
&mut self.background_color,
|
|
|
|
&mut self.renderer,
|
|
|
|
&mut self.audio,
|
2019-09-01 19:24:04 +00:00
|
|
|
&mut self.navigator,
|
2019-09-02 03:03:50 +00:00
|
|
|
&mut self.rng,
|
2019-08-26 23:38:37 +00:00
|
|
|
&mut self.is_mouse_down,
|
|
|
|
);
|
|
|
|
|
|
|
|
self.gc_arena.mutate(|gc_context, gc_root| {
|
|
|
|
let mut update_context = UpdateContext {
|
2019-10-09 00:07:00 +00:00
|
|
|
player_version,
|
2019-08-26 23:38:37 +00:00
|
|
|
global_time,
|
|
|
|
swf_data,
|
|
|
|
swf_version,
|
|
|
|
library: gc_root.library.write(gc_context),
|
|
|
|
background_color,
|
2019-08-26 22:53:50 +00:00
|
|
|
avm: gc_root.avm.write(gc_context),
|
2019-09-02 03:03:50 +00:00
|
|
|
rng,
|
2019-08-26 23:38:37 +00:00
|
|
|
renderer,
|
|
|
|
audio,
|
2019-09-01 19:24:04 +00:00
|
|
|
navigator,
|
2019-08-26 23:38:37 +00:00
|
|
|
actions: vec![],
|
|
|
|
gc_context,
|
|
|
|
active_clip: gc_root.root,
|
|
|
|
};
|
|
|
|
|
|
|
|
if let Some(node) = &*gc_root.mouse_hover_node.read() {
|
|
|
|
if let Some(button) = node.write(gc_context).as_button_mut() {
|
|
|
|
match event {
|
|
|
|
PlayerEvent::MouseDown { .. } => {
|
|
|
|
*is_mouse_down = true;
|
|
|
|
needs_render = true;
|
|
|
|
update_context.active_clip = *node;
|
|
|
|
button.handle_button_event(&mut update_context, ButtonEvent::Press);
|
|
|
|
}
|
|
|
|
|
|
|
|
PlayerEvent::MouseUp { .. } => {
|
|
|
|
*is_mouse_down = false;
|
|
|
|
needs_render = true;
|
|
|
|
update_context.active_clip = *node;
|
|
|
|
button.handle_button_event(&mut update_context, ButtonEvent::Release);
|
|
|
|
}
|
|
|
|
|
|
|
|
_ => (),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Self::run_actions(&mut update_context, gc_root.root);
|
|
|
|
});
|
|
|
|
|
|
|
|
if needs_render {
|
|
|
|
// Update display after mouse events.
|
|
|
|
self.render();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn update_roll_over(&mut self) -> bool {
|
2019-10-09 00:07:00 +00:00
|
|
|
let player_version = self.player_version;
|
2019-08-26 23:38:37 +00:00
|
|
|
// TODO: While the mouse is down, maintain the hovered node.
|
|
|
|
if self.is_mouse_down {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-09-02 03:03:50 +00:00
|
|
|
let (global_time, swf_data, swf_version, background_color, renderer, audio, navigator, rng) = (
|
2019-08-26 23:38:37 +00:00
|
|
|
self.global_time,
|
|
|
|
&mut self.swf_data,
|
|
|
|
self.swf_version,
|
|
|
|
&mut self.background_color,
|
|
|
|
&mut self.renderer,
|
|
|
|
&mut self.audio,
|
2019-09-02 03:03:50 +00:00
|
|
|
&mut self.navigator,
|
2019-09-17 03:37:11 +00:00
|
|
|
&mut self.rng,
|
2019-08-26 23:38:37 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
let mouse_pos = &self.mouse_pos;
|
|
|
|
// Check hovered object.
|
|
|
|
self.gc_arena.mutate(|gc_context, gc_root| {
|
|
|
|
let new_hover_node = gc_root
|
|
|
|
.root
|
|
|
|
.read()
|
|
|
|
.mouse_pick(gc_root.root, (mouse_pos.0, mouse_pos.1));
|
|
|
|
let mut cur_hover_node = gc_root.mouse_hover_node.write(gc_context);
|
|
|
|
if cur_hover_node.map(GcCell::as_ptr) != new_hover_node.map(GcCell::as_ptr) {
|
|
|
|
let mut update_context = UpdateContext {
|
2019-10-09 00:07:00 +00:00
|
|
|
player_version: player_version,
|
2019-08-26 23:38:37 +00:00
|
|
|
global_time,
|
|
|
|
swf_data,
|
|
|
|
swf_version,
|
|
|
|
library: gc_root.library.write(gc_context),
|
|
|
|
background_color,
|
2019-08-26 22:53:50 +00:00
|
|
|
avm: gc_root.avm.write(gc_context),
|
2019-09-02 03:03:50 +00:00
|
|
|
rng,
|
2019-08-26 23:38:37 +00:00
|
|
|
renderer,
|
|
|
|
audio,
|
2019-09-01 19:24:04 +00:00
|
|
|
navigator,
|
2019-08-26 23:38:37 +00:00
|
|
|
actions: vec![],
|
|
|
|
gc_context,
|
|
|
|
active_clip: gc_root.root,
|
|
|
|
};
|
|
|
|
|
|
|
|
// RollOut of previous node.
|
|
|
|
if let Some(node) = &*cur_hover_node {
|
|
|
|
if let Some(button) = node.write(gc_context).as_button_mut() {
|
|
|
|
update_context.active_clip = *node;
|
|
|
|
button.handle_button_event(&mut update_context, ButtonEvent::RollOut);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// RollOver on new node.
|
|
|
|
if let Some(node) = new_hover_node {
|
|
|
|
if let Some(button) = node.write(gc_context).as_button_mut() {
|
|
|
|
update_context.active_clip = node;
|
|
|
|
button.handle_button_event(&mut update_context, ButtonEvent::RollOver);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*cur_hover_node = new_hover_node;
|
|
|
|
|
|
|
|
Self::run_actions(&mut update_context, gc_root.root);
|
|
|
|
true
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
fn preload(&mut self) {
|
2019-10-09 00:07:00 +00:00
|
|
|
let (
|
|
|
|
player_version,
|
|
|
|
global_time,
|
|
|
|
swf_data,
|
|
|
|
swf_version,
|
|
|
|
background_color,
|
|
|
|
renderer,
|
|
|
|
audio,
|
|
|
|
navigator,
|
|
|
|
rng,
|
|
|
|
) = (
|
|
|
|
self.player_version,
|
2019-08-26 23:38:37 +00:00
|
|
|
self.global_time,
|
|
|
|
&mut self.swf_data,
|
|
|
|
self.swf_version,
|
|
|
|
&mut self.background_color,
|
|
|
|
&mut self.renderer,
|
|
|
|
&mut self.audio,
|
2019-09-01 19:24:04 +00:00
|
|
|
&mut self.navigator,
|
2019-09-17 03:37:11 +00:00
|
|
|
&mut self.rng,
|
2019-08-26 23:38:37 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
self.gc_arena.mutate(|gc_context, gc_root| {
|
|
|
|
let mut update_context = UpdateContext {
|
2019-10-09 00:07:00 +00:00
|
|
|
player_version: player_version,
|
2019-08-26 23:38:37 +00:00
|
|
|
global_time,
|
|
|
|
swf_data,
|
|
|
|
swf_version,
|
|
|
|
library: gc_root.library.write(gc_context),
|
|
|
|
background_color,
|
2019-08-26 22:53:50 +00:00
|
|
|
avm: gc_root.avm.write(gc_context),
|
2019-09-02 03:03:50 +00:00
|
|
|
rng,
|
2019-08-26 23:38:37 +00:00
|
|
|
renderer,
|
|
|
|
audio,
|
2019-09-01 19:24:04 +00:00
|
|
|
navigator,
|
2019-08-26 23:38:37 +00:00
|
|
|
actions: vec![],
|
|
|
|
gc_context,
|
|
|
|
active_clip: gc_root.root,
|
|
|
|
};
|
|
|
|
|
2019-09-05 05:44:35 +00:00
|
|
|
let mut morph_shapes = fnv::FnvHashMap::default();
|
2019-09-06 22:19:59 +00:00
|
|
|
gc_root
|
|
|
|
.root
|
|
|
|
.write(gc_context)
|
|
|
|
.as_movie_clip_mut()
|
|
|
|
.unwrap()
|
|
|
|
.preload(&mut update_context, &mut morph_shapes);
|
2019-09-05 05:44:35 +00:00
|
|
|
|
|
|
|
// Finalize morph shapes.
|
|
|
|
for (id, static_data) in morph_shapes {
|
2019-10-13 21:27:04 +00:00
|
|
|
let morph_shape = crate::morph_shape::MorphShape::new(gc_context, static_data);
|
2019-09-06 22:19:59 +00:00
|
|
|
update_context.library.register_character(
|
|
|
|
id,
|
|
|
|
crate::character::Character::MorphShape(Box::new(morph_shape)),
|
|
|
|
);
|
2019-09-05 05:44:35 +00:00
|
|
|
}
|
2019-08-26 23:38:37 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn run_frame(&mut self) {
|
2019-10-09 00:07:00 +00:00
|
|
|
let (
|
|
|
|
player_version,
|
|
|
|
global_time,
|
|
|
|
swf_data,
|
|
|
|
swf_version,
|
|
|
|
background_color,
|
|
|
|
renderer,
|
|
|
|
audio,
|
|
|
|
navigator,
|
|
|
|
rng,
|
|
|
|
) = (
|
|
|
|
self.player_version,
|
2019-08-26 23:38:37 +00:00
|
|
|
self.global_time,
|
|
|
|
&mut self.swf_data,
|
|
|
|
self.swf_version,
|
|
|
|
&mut self.background_color,
|
|
|
|
&mut self.renderer,
|
|
|
|
&mut self.audio,
|
2019-09-02 03:03:50 +00:00
|
|
|
&mut self.navigator,
|
2019-09-17 03:37:11 +00:00
|
|
|
&mut self.rng,
|
2019-08-26 23:38:37 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
self.gc_arena.mutate(|gc_context, gc_root| {
|
|
|
|
let mut update_context = UpdateContext {
|
2019-10-09 00:07:00 +00:00
|
|
|
player_version: player_version,
|
2019-08-26 23:38:37 +00:00
|
|
|
global_time,
|
|
|
|
swf_data,
|
|
|
|
swf_version,
|
|
|
|
library: gc_root.library.write(gc_context),
|
|
|
|
background_color,
|
2019-08-26 22:53:50 +00:00
|
|
|
avm: gc_root.avm.write(gc_context),
|
2019-09-02 03:03:50 +00:00
|
|
|
rng,
|
2019-08-26 23:38:37 +00:00
|
|
|
renderer,
|
|
|
|
audio,
|
2019-09-01 19:24:04 +00:00
|
|
|
navigator,
|
2019-08-26 23:38:37 +00:00
|
|
|
actions: vec![],
|
|
|
|
gc_context,
|
|
|
|
active_clip: gc_root.root,
|
|
|
|
};
|
|
|
|
|
|
|
|
gc_root
|
|
|
|
.root
|
|
|
|
.write(gc_context)
|
|
|
|
.run_frame(&mut update_context);
|
|
|
|
|
|
|
|
Self::run_actions(&mut update_context, gc_root.root);
|
|
|
|
});
|
|
|
|
|
|
|
|
// Update mouse state (check for new hovered button, etc.)
|
|
|
|
self.update_roll_over();
|
|
|
|
|
|
|
|
// GC
|
|
|
|
self.gc_arena.collect_debt();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn render(&mut self) {
|
|
|
|
let view_bounds = BoundingBox {
|
|
|
|
x_min: Twips::new(0),
|
|
|
|
y_min: Twips::new(0),
|
|
|
|
x_max: Twips::from_pixels(self.movie_width.into()),
|
|
|
|
y_max: Twips::from_pixels(self.movie_height.into()),
|
|
|
|
valid: true,
|
|
|
|
};
|
|
|
|
|
|
|
|
self.renderer.begin_frame();
|
|
|
|
|
|
|
|
self.renderer.clear(self.background_color.clone());
|
|
|
|
|
|
|
|
let (renderer, transform_stack) = (&mut self.renderer, &mut self.transform_stack);
|
|
|
|
|
|
|
|
transform_stack.push(&crate::transform::Transform {
|
|
|
|
matrix: self.view_matrix,
|
|
|
|
..Default::default()
|
|
|
|
});
|
|
|
|
self.gc_arena.mutate(|_gc_context, gc_root| {
|
|
|
|
let mut render_context = RenderContext {
|
|
|
|
renderer,
|
|
|
|
library: gc_root.library.read(),
|
|
|
|
transform_stack,
|
|
|
|
view_bounds,
|
2019-09-08 02:33:06 +00:00
|
|
|
clip_depth_stack: vec![],
|
2019-08-26 23:38:37 +00:00
|
|
|
};
|
|
|
|
gc_root.root.read().render(&mut render_context);
|
|
|
|
});
|
|
|
|
transform_stack.pop();
|
|
|
|
|
|
|
|
if !self.is_playing() {
|
|
|
|
self.renderer.draw_pause_overlay();
|
|
|
|
}
|
|
|
|
|
|
|
|
self.renderer.draw_letterbox(self.letterbox);
|
|
|
|
self.renderer.end_frame();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn renderer(&self) -> &Renderer {
|
|
|
|
&self.renderer
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn renderer_mut(&mut self) -> &mut Renderer {
|
|
|
|
&mut self.renderer
|
|
|
|
}
|
|
|
|
|
|
|
|
fn run_actions<'gc>(update_context: &mut UpdateContext<'_, 'gc, '_>, root: DisplayNode<'gc>) {
|
|
|
|
// TODO: Loop here because goto-ing a frame can queue up for actions.
|
|
|
|
// I think this will eventually be cleaned up;
|
|
|
|
// Need to figure out the proper order of operations between ticking a clip
|
|
|
|
// and running the actions.
|
|
|
|
let mut actions = std::mem::replace(&mut update_context.actions, vec![]);
|
|
|
|
while !actions.is_empty() {
|
|
|
|
{
|
|
|
|
let mut action_context = crate::avm1::ActionContext {
|
|
|
|
gc_context: update_context.gc_context,
|
|
|
|
global_time: update_context.global_time,
|
|
|
|
root,
|
2019-10-09 00:07:00 +00:00
|
|
|
player_version: update_context.player_version,
|
2019-08-26 23:38:37 +00:00
|
|
|
start_clip: root,
|
|
|
|
active_clip: root,
|
2019-09-17 09:00:57 +00:00
|
|
|
target_clip: Some(root),
|
2019-09-17 17:28:10 +00:00
|
|
|
target_path: crate::avm1::Value::Undefined,
|
2019-09-02 03:03:50 +00:00
|
|
|
rng: update_context.rng,
|
2019-08-26 23:38:37 +00:00
|
|
|
audio: update_context.audio,
|
2019-09-01 19:24:04 +00:00
|
|
|
navigator: update_context.navigator,
|
2019-08-26 23:38:37 +00:00
|
|
|
};
|
|
|
|
for (active_clip, action) in actions {
|
|
|
|
action_context.start_clip = active_clip;
|
|
|
|
action_context.active_clip = active_clip;
|
2019-09-17 09:00:57 +00:00
|
|
|
action_context.target_clip = Some(active_clip);
|
2019-10-06 21:46:49 +00:00
|
|
|
update_context.avm.insert_stack_frame_for_action(
|
|
|
|
update_context.swf_version,
|
|
|
|
action,
|
|
|
|
&mut action_context,
|
|
|
|
);
|
2019-09-15 21:57:35 +00:00
|
|
|
let _ = update_context.avm.run_stack_till_empty(&mut action_context);
|
2019-08-26 23:38:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Run goto queues.
|
|
|
|
update_context.active_clip = root;
|
|
|
|
root.write(update_context.gc_context)
|
|
|
|
.run_post_frame(update_context);
|
|
|
|
|
|
|
|
actions = std::mem::replace(&mut update_context.actions, vec![]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn build_matrices(&mut self) {
|
|
|
|
// Create view matrix to scale stage into viewport area.
|
|
|
|
let (movie_width, movie_height) = (self.movie_width as f32, self.movie_height as f32);
|
|
|
|
let (viewport_width, viewport_height) =
|
|
|
|
(self.viewport_width as f32, self.viewport_height as f32);
|
|
|
|
let movie_aspect = movie_width / movie_height;
|
|
|
|
let viewport_aspect = viewport_width / viewport_height;
|
|
|
|
let (scale, margin_width, margin_height) = if viewport_aspect > movie_aspect {
|
|
|
|
let scale = viewport_height / movie_height;
|
|
|
|
(scale, (viewport_width - movie_width * scale) / 2.0, 0.0)
|
|
|
|
} else {
|
|
|
|
let scale = viewport_width / movie_width;
|
|
|
|
(scale, 0.0, (viewport_height - movie_height * scale) / 2.0)
|
|
|
|
};
|
|
|
|
self.view_matrix = Matrix {
|
|
|
|
a: scale,
|
|
|
|
b: 0.0,
|
|
|
|
c: 0.0,
|
|
|
|
d: scale,
|
|
|
|
tx: margin_width * 20.0,
|
|
|
|
ty: margin_height * 20.0,
|
|
|
|
};
|
|
|
|
self.inverse_view_matrix = self.view_matrix;
|
|
|
|
self.inverse_view_matrix.invert();
|
|
|
|
|
|
|
|
// Calculate letterbox dimensions.
|
|
|
|
// TODO: Letterbox should be an option; the original Flash Player defaults to showing content
|
|
|
|
// in the extra margins.
|
|
|
|
self.letterbox = if margin_width > 0.0 {
|
|
|
|
Letterbox::Pillarbox(margin_width)
|
|
|
|
} else if margin_height > 0.0 {
|
|
|
|
Letterbox::Letterbox(margin_height)
|
|
|
|
} else {
|
|
|
|
Letterbox::None
|
|
|
|
};
|
|
|
|
}
|
2019-10-08 04:02:09 +00:00
|
|
|
|
|
|
|
/// Loads font data from the given buffer.
|
|
|
|
/// The buffer should be the `DefineFont3` info for the tag.
|
|
|
|
/// The tag header should not be included.
|
|
|
|
fn load_device_font(
|
|
|
|
data: &[u8],
|
|
|
|
renderer: &mut Renderer,
|
|
|
|
) -> Result<Box<crate::font::Font>, Error> {
|
|
|
|
let mut reader = swf::read::Reader::new(data, 8);
|
|
|
|
let device_font = Box::new(crate::font::Font::from_swf_tag(
|
|
|
|
renderer,
|
|
|
|
&reader.read_define_font_2(3)?,
|
|
|
|
)?);
|
|
|
|
Ok(device_font)
|
|
|
|
}
|
2019-08-26 23:38:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub struct UpdateContext<'a, 'gc, 'gc_context> {
|
2019-10-09 00:07:00 +00:00
|
|
|
pub player_version: u8,
|
2019-08-26 23:38:37 +00:00
|
|
|
pub swf_version: u8,
|
|
|
|
pub swf_data: &'a Arc<Vec<u8>>,
|
|
|
|
pub global_time: u64,
|
|
|
|
pub library: std::cell::RefMut<'a, Library<'gc>>,
|
|
|
|
pub gc_context: MutationContext<'gc, 'gc_context>,
|
|
|
|
pub background_color: &'a mut Color,
|
2019-08-26 22:53:50 +00:00
|
|
|
pub avm: std::cell::RefMut<'a, Avm1<'gc>>,
|
2019-08-26 23:38:37 +00:00
|
|
|
pub renderer: &'a mut dyn RenderBackend,
|
|
|
|
pub audio: &'a mut dyn AudioBackend,
|
2019-09-01 19:24:04 +00:00
|
|
|
pub navigator: &'a mut dyn NavigatorBackend,
|
2019-09-02 03:03:50 +00:00
|
|
|
pub rng: &'a mut SmallRng,
|
2019-08-26 23:38:37 +00:00
|
|
|
pub actions: Vec<(DisplayNode<'gc>, crate::tag_utils::SwfSlice)>,
|
|
|
|
pub active_clip: DisplayNode<'gc>,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct RenderContext<'a, 'gc> {
|
|
|
|
pub renderer: &'a mut dyn RenderBackend,
|
|
|
|
pub library: std::cell::Ref<'a, Library<'gc>>,
|
|
|
|
pub transform_stack: &'a mut TransformStack,
|
|
|
|
pub view_bounds: BoundingBox,
|
2019-09-08 02:33:06 +00:00
|
|
|
pub clip_depth_stack: Vec<Depth>,
|
2019-08-26 23:38:37 +00:00
|
|
|
}
|