ryanisaacg / quicksilver Goto Github PK

View Code? Open in Web Editor NEW

784.0 27.0 78.0 10.63 MB

A simple framework for 2D games on desktop and web

Home Page: https://ryanisaacg.github.io/quicksilver

License: Other

Rust 99.20% Shell 0.80%

rust-library gamedev pure-rust rust wasm game-engine game-engine-2d

quicksilver's Introduction

quicksilver

A simple 2D game framework written in pure Rust, for both the Web and Desktop

Maintenance Status

I've posted an update on my website about Quicksilver. To keep a long story short: Quicksilver is no longer actively developed. For now I will continue to triage bugs and pull requests and (maybe) fix small bugs.

Alpha Notice

This version of Quicksilver is currently working its way through alpha! There is still work to do on the API and on bugfixes, as well as waiting on an upstream library for audio support. Please feel free to use this version and provide feedback! If you run into bugs or want to give feedback on API decisions, please open an issue.

A quick example

Create a rust project and add this line to your Cargo.toml file under [dependencies]:

quicksilver = "0.4"

Then replace src/main.rs with the following (the contents of quicksilver's examples/01_square.rs):

// Example 1: The Square
// Open a window, and draw a colored square in it
use quicksilver::{
    geom::{Rectangle, Vector},
    graphics::Color,
    run, Graphics, Input, Result, Settings, Window,
};

fn main() {
    run(
        Settings {
            title: "Square Example",
            ..Settings::default()
        },
        app,
    );
}

async fn app(window: Window, mut gfx: Graphics, mut input: Input) -> Result<()> {
    // Clear the screen to a blank, white color
    gfx.clear(Color::WHITE);
    // Paint a blue square with a red outline in the center of our screen
    // It should have a top-left of (350, 100) and a size of (150, 100)
    let rect = Rectangle::new(Vector::new(350.0, 100.0), Vector::new(100.0, 100.0));
    gfx.fill_rect(&rect, Color::BLUE);
    gfx.stroke_rect(&rect, Color::RED);
    // Send the data to be drawn
    gfx.present(&window)?;
    loop {
        while let Some(_) = input.next_event().await {}
    }
}

Learning Quicksilver

A good way to get started with Quicksilver is to read and run the examples which also serve as tutorials. If you have any questions, feel free to open an issue or ask for help in the Rust Community Discord from other Quicksilver users and developers.

Made with Quicksilver

Version 0.4

Libraries
- Lenscas: Silver_Animation - An animation system
- Lenscas: Mergui - A simple GUI system
- johnpmayer: quicksilver-utils-async - Tasks, timers, and net code
- johnpmayer: quicksilver-utils-ecs - Entity Component System integrations
Games
- alec-deason: Pixel Imperfect

Version 0.3

Documentation / Tutorials
- tomassedovic: quicksilver-roguelike
Games
Libraries
- Lenscas: Mergui - A simple GUI system

Want to add your project? Feel free to open an issue or PR!

Building and Deploying a Quicksilver application

Quicksilver should always compile and run on the latest stable version of Rust, for both web and desktop.

Make sure to put all your assets in a top-level folder of your crate called static/. All Quicksilver file loading-APIs will expect paths that originate in the static folder, so static/image.png should be referenced as image.png.

Linux dependencies

On Windows and Mac, all you'll need to build Quicksilver is a recent stable version of rustc and cargo. A few of Quicksilver's dependencies require Linux packages to build, namely libudev, zlib, and alsa. To install these on Ubuntu or Debian, run the command sudo apt install libudev-dev zlib1g-dev alsa libasound2-dev.

Deploying for desktop

If you're deploying for desktop platforms, build in release mode (cargo build --release) and copy the executable file produced (found at "target/release/") and any assets you used (image files, etc.) and create an archive (on Windows a zip file, on Unix a tar file). You should be able to distribute this archive with no problems; if there are any, please open an issue.

Deploying for the web

If you're deploying for the web, first make sure you've installed the cargo web tool. Then use cargo web deploy to build your application for distribution (located at target/deploy).

If you want to test your application locally, use cargo web start --features quicksilver/stdweb and open your favorite browser to the port it provides.

wasm-bindgen support

Quicksilver has recently gained experimental support for wasm-bindgen, under the web-sys feature. The workflow is not currently documented here, but it should be the same as using any other library with wasm-bindgen.

Optional Features

Quicksilver by default tries to provide all features a 2D application may need, but not all applications need these features.

The optional features available are:

easy logging (via log, simple_logger, and web_logger)
gamepad event generation (via gilrs)
saving (via gestalt)
font rendering (via elefont) and TTF parsing (via rusttype)

Each are enabled by default, but you can specify which features you actually want to use.

Supported Platforms

The engine is supported on Windows, macOS, Linux, and the web via WebAssembly.

Mobile support would be a future possibility, but likely only through external contributions.

quicksilver's People

Contributors

Stargazers

Watchers

Forkers

shadowshows anderspitman brandonhamilton doumanash gitter-badger beatgammit 999eagle cryze song9446 memoryruins codesteak sseemayer xoronic gogobook mdonoughe riey 0b01 kurble rsribeiro tomassedovic dtibbs ratysz ingrid batonius robotcaleb brandonson bugsbunny1101 hughlang lassade electron-libre seanvoss zesterer wasm-network giesch zacharied francesco-cattoglio masums meerkat-company nico-abram dallasc maikklein jakmeier martinlindhe tannerrogalsky bgourlie maulingmonkey zhisder johnpmayer badlydrawnrod leinnan vugluskr86 cedric-h kristoncosta frozolotl ritalin leod safarimonkey samipirbay anthonyyomanz colrad sssilver lenscas paulirotta alec-deason minusgix coolreader18 jac3km4 risooonho liamolucko amphr rieryn pharmhaus-2 ajunlonglive samuelb7 iq-scm fraglimima lykme516 lumoping

quicksilver's Issues

Temporary state are cleared away too soon

Temporary states are cleared every frame, despite updates only being occasional instead of every frame.

The user should be able to choose between linear and nearest scaling

Gradients for shape rendering

Create a function to check to see if a list of Loadable objects is loaded

A loading screen should be able to quickly test to see if all its assets are loaded, and if they are it should be able to turn them into their loaded form.

Tutorial-style / "soft" documentation

The project is configured to force all public members to be documented, but currently there are no walkthroughs / tutorials that take new users through an introduction to the library.

Code coverage isn't reporting correctly

codecov isn't showing files that are completely uncovered (Window, WindowBuilder) which is artificially inflating the code coverage.

Document the limitations of WASM

If users plan to target WASM, they should be aware of limitations like lack of threading and lack of ability to roll their own main.

Set window icon

There should be some way to set the icon for native and the favicon for web, but this may require platform-specific code (Glutin / winit currently provide no way to do this.)

The type passed into update_all should be more flexible

Add the ability to enable / disable resizing

The WindowBuilder should have a resizing configuration

Document the defaults for the WindowBuilder

Question : do you have or plan to support font rendering ?

Hello,

sorry if it is not the good way of asking question :)

thanks

Remove WindowBuilder entirely

Because there are no features WindowBuilder can enable that Window cannot, it seems best to just allow the user to edit the Window defaults rather than the ceremony of the builder pattern.

It's not obvious how to obtain Keyboard and Mouse from their documentation pages

Font support

Currently there is no text rendering mechanism in quicksilver which is an important feature.

Vector should have a with_length function

Screen / state management

Because the game_loop macro require all control flow through a single struct and its associated functions, there should be some convenient mechanism to embed multiple screens / states within the struct.

Mouse wheel handling

There should be some way to handle mouse wheel inputs, which will require new JS hooks

Texture atlas support

Batched drawing means that switching textures is slower than not, and a texture atlas would greatly reduce the number of times the texture must be switched.

Module and crate level documentation

Some way to cache CStrings and JS strings for GL

every time the buffers are reallocated there will be garbage created to find the GL attributes; that memory could be cached instead.

Local game saving

There should be a way to save items to a configuration file, in different locations on native and in page cookies in web.

Configurable letterboxing

There should be options for not resizing at all, stretching with no letterboxing, etc.

LoadingAsset should not require members to have a load function

The function used to create a LoadingAsset isn't important; what's important is that it can be updated.

Spritesheet support

There should be a quick way to load horizontal sprites into an array

Gamepad support

It doesn't appear that Glutin supports gamepads, so this might not be possible without code for each native platform, but it's still something to consider.

Switch the Arc for the Image back to an Rc

Because the Image really shouldn't be passed between threads Arc is just burning performance for no reason.

Viewports are broken when Windows resize

Because a Viewport can be kept around after a Window is resized, it can become invalidated.

The first played sound causes a significant performance drop on desktop

Presumably, rodio/cpal is initializing which is expensive.

Rework the viewport / camera API to unify the creation of both

There should be a simple way to create both a camera (drawing) and a viewport (input) focusing on the same region.

Letterboxing is broken

The GL context doesn't automatically resize

Glutin isn't guaranteed to resize the GL context as the windo resizes, and it won't on on macOS and wayland.

Add all platforms to CI

Add mac CI
Add windows to CI

update_all should return errors if they occur

A way to retrieve the most recently pressed key

When it comes to something like rebinding controls, polling specific keys isn't the best option

Build examples for the web and link to them in the README

Comparison with GGEZ

Tiled drawing should be faster

There should be a simple API to draw a tile over an area and it should be optimized for tiled drawing

Mouse button should be functions, not variables

Color blending with the Color struct

Allow reconfiguration of options from the Window

See #32

More / better options for the game loop macro

As it stands the game loop macro is fairly restrictive on the main structure of your program.

Create fullscreen options

On desktop, if only one of native fullscreen and borderless window is possible, borderless window is probably to be preferred. In JS, the browser window will have to be fullscreened and so will the content. Additionally, this requires setting the JS viewport to letterbox.