When reading an SWF, search for FileAttributes and
SetBackgroundColor and return this along with the header data
because it's useful (in particular, the AS3 flag).
Toss out any shared objects that contain ".." in the name
to avoid accessing files outside of the Ruffle data directory.
The DiskStorageBackend also will fail any requests with a ".."
component as an extra precaution.
Fixes#3961.
Also, prefix the shared object name with # if it contains a
slash, (e.g. `#mygame/foo`). This matches Flash's directory
structure and makes it easier to transfer saved data to Ruffle.
This adds two optional parameters, --width and --height, which
allow the user to specify a desired physical window width and
height to be used. If only one of the two parameters is present,
the other will be deduced from it and the movie's aspect ratio.
If neither are present, the window's size is set to the movie's
logical size, in accordance with the behaviour before this change.
* #[derive(Collect)] should be before #[collect]
* Replace redunant `&buf[..]` with `buf`
* Changes most cases of UPPERCase to UpperCase
* Allow upper_case_acronym on most SWF types, as they are from
SWF spec/more annoying to change.
It might not succeed.
This unwrap crashes the newgrounds Meat Boy flash on desktop.
Instead, use unwrap_or_default with an empty path. This will cause
the read to fail, but it's better than crashing the whole program.
The points in an SWF sound envelope are always in 44.1KHz. The
desktop audio backend would end up using this points in the sound's
sample rate, often causing the envelope to be delayed.
Now the envelope is applied after resampling, and the positions
are scaled based on the output sample rate.
This unifies the code path for event sounds and stream sounds.
Both `AudioBackend::start_stream` and `start_sound` return a
`SoundHandle`. `stop_stream` is removed (`stop_sound` can be
used for both cases).
Also removes references to `CharacterId` from the `AudioBackend`
(instead, an increasing ID is returned to identiy streams while
loading).
Add an AudioManager struct to handle this list of actively playing
sounds. This will maintain information for each sound instance,
such as the owning display object, AVM1 object, etc.
This will allow us to implement the awkward AVM1 Sound API in a
fairly backend-agnostic way.
Basically just copied from what alacritty is doing:
530de00049/alacritty/src/main.rs
There are two functional changes:
- When launching normally, you no longer see a console window quickly flashing
- When launching via. console, the program is detached (but still logs to the console)
By default, winit limits the window size to the screen resolution.
Since some flashes are larger than this, increase the limit to an
arbitrarily-chosen larger constant.
Winit's WindowBuilder will sometimes create a window whose size is
smaller than requested. Therefore, instead of assuming the actual
window size is requested size * scaling, just check what the true
size is. (window.inner_size() also takes scaling into account.)
This fixes at least one issue where rendering would fail on Windows
with the Vulkan backend due to the incorrect size being used.
Player::set_letterbox can be used to control the letterbox behavior.
* Letterbox::Off => no letterbox (flash behavior)
* Letterbox::Fullscreen => letterbox only in fullscreen (web default)
* Letterbox::On => always letterbox (desktop default)
On desktop, don't render while the window is minimized.
In the wgpu backend, don't panic if swap chain fails to grab a
texture. Instead recreate the swap chain and bail on the current
frame.
Fixes panic when minimizing with the wgpu vulkan backend (#2065).
Add --timedemo for benchmarking, which will run the given SWF as
quickly as possible for 5000 frames or the end of the root
timeline, whichever comes first. The total duration will be output
upon completion.
sample renamed into dasp. Switch to this crate and also use the
latest git revision, which fixed some compiler errors on nightly.
Also remove unnecessary sample dependency in exporter Cargo.toml.
- removed default implementations for `play()` and `pause()` methods for AudioBackend trait
- Implemented `play()` and `pause()` methods for CPAL audio backend
- Implemented empty block for `play()` and `pause()` methods for NULL audio backend
When using ALSA, cpal was returning bogus sample rates from
`Device::supported_output_configs`, causing the audio stream to
fail to initialize.
Use `Device::default_output_config` instead.
During the small period of time when a player is created but has no root movie, a temporary empty movie is installed with an assumed stage size and framerate of 550x400@12fps. This is Flash default for new projects, so it seemed appropriate. User ActionScript cannot see these values, and I'm not even sure JavaScript can, either.
Remove #![windows_subsystem = "windows"], which launched us as a
GUI app on win32. However, this had the side effect of hiding
output to stdout/stderr when launched from the command-line.
Since Ruffle is primarily a CLI interface as of yet, let's revert
back to a console win32 app so that we can display output. Instead,
we can hide the console if we detect we were not launched from the
command line.
On the desktop player, shared objects will now be flushed on quit.
Attempting to retrieve an existing shared object will now return a
reference to the existing one.
No longer show a command line window when opening a file with ruffle via a file association (open with).
Co-authored-by: Genna Wingert <wingertge@gmail.com>
When creating the viewport on desktop, the window DPI was not taken
into account, which may result in a blank screen until resized
(reported in #548). The window dimensions are now converted to
physical coordinates before passing them to the renderer.
Don't call `render` from `Player::tick`; instead, require the
frontends to explicitly call `render` when they wish to redraw.
The frontend can query `Player::needs_render` to see if the stage
is dirty and needs a redraw. Update desktop and web to use this
new method.
This fits better with the newer winit event loop model, which
requires explicitly calling `request_redraw`, and should avoid
spurious renders.
Change `ActionGetTime` (`getTimer`) to use a new backend method.
This allows it to return updated times if it is called multiple
times in a single frame. This fixes hangs caused by games that use
busy-loop "frame limiter" code.
It doesn't feel like Flash without having the hand cursor display
when hovering over buttons. First pass at implementing this;
core communicates which mouse cursor to use via
`InputBackend::set_mouse_cursor`.
TODO: Hand cursor only displayed for Button display objects
currently. Movie clips should also display this when they are in
"button mode" (when a button mouse event is set on them in AVM1,
or `buttonMode` property in AVM2).
This allows the formation of `'static` futures that can still interact with a player. Async code will need to upgrade the weak reference in order to be able to interact with the player.
Due to some strangeness with the way Rust implemented unsafe-to-move behavior, boxed futures are implicitly `Unpin`. Which is useless to us.
The reason for this is a little counter-intuitive. Actually, the fact that Rust supports memory pinning at all is a little odd, because the core language explicitly requires all types be movable. To get around this, Pin requires that all !Unpin types be *born pinned*. This is because you can't re-pin an already unpinned value in memory.
Anyway, this necessitates this silly API change.