stdweb | A standard library for the client-side Web

The importing of WebAssembly modules is not yet standardized. You should set the --target argument of wasm-pack to web to generate JavaScript to use in a browser.

In your example game_loop owns game, as it is moved into the loop. So anything that should change game needs to happen inside game_loop. To fit event handling into this, you have multiple options:

Let the game_loop poll for events.

You create a queue of events and your game_loop will have some logic to get the first event and handle it.

You will have to deal with synchronization here, so I suggest that you read up on Mutex and Concurrency in general. But it should be a fairly easy task once you get the hang of it. Your loop gets one reference and each event handler gets one, all try to unlock the mutex and then access the queue (vector probably).

This will make your game_loop the monolithic one truth of them all, which is a popular engine design because it is easy to reason about and start with.

But maybe you want to be less centralized.

Let events happen outside the loop

This idea would be a bigger refactor. You would put your Game in a lazy_static with a Mutex around it.

Every invocation of the game_loop it will try to get the lock on said Mutex and then perform game calculations.

When an input event happens, that event also tries to get the Mutex on the Game. This means while the game_loop is processing, no input events are handled, but they will try to get in between ticks.

A challenge here would be to preserve input order and to make sure that inputs are processed quick enough. This might be a bigger challenge to get completely right. But the design will give you some possibilities.

A fleshed out version of this idea is Amethyst, which is massively parallel and makes for a clean design. But they employ a quite more complex design behind their engine.

I managed to access the file object and pass it to the FileReaderin the following way:

Unfortunately you're working on the bleeding edge here! WebAssembly streaming compilation is a very new feature that is only currently supported in FireFox and Chrome.

You are right that it depends on files being server with the correct mime-type. The changes required to make this happen being made:

• node-mime - which is used by many projects (including webpack dev server) to provide mime type based on file extension, was updated to support wasm in Dec 2017 in v2.3.1
• webpack-dev-middleware was updated in Nov 2017 to support wasm file extension in v3.1.3

However, these are both up-stream dependencies of create-react-app, via react-scripts. The bleeding edge version of react-scripts has a dependency on webback-dev-middleware that supports wasm, however this hasn't been released yet. The latest version on npm uses an older version.

For now, I'd turn of streaming compilation until these changes make it into 'production'.

I couldn't call a Rust function by name from JavaScript unless I exported it first (#[js_export]). However, the js! macro from the stdweb library allows JavaScript code to call a regular Rust function:

Looking at the doc of stdweb::Value, it seems they have you covered!

It implements TryFrom, with JsonValue being an alias of serde_json::Value, so this lets you converts from serde_json::Value to stdweb::Value.

It implements Serialize, and serde_json::to_value lets you convert any type that implements Serialize to a serde_json::Value

So this should work: