Is it possible to suspend a running Rhai script and resume it later?

[casey]

We're thinking of using Rhai as the scripting language for a generative art toy thing. Users would write Rhai scripts that interact with the rendering engine to make cool images. One tricky requirement that we have is that we need a way to suspend user scripts after they draw a frame, return control to the browser so it can display the rendered frame, and then resume execution of the script where it left off. Something like this would be ideal:

// example user script

loop {
    render_frame();
    yield; // using an imaginary `yield` keyword that returns control to the rust caller, which can then resume execution later
}

Is something like this possible?

[schungx]

Not at this time. You're asking for async (which is essentially suspend-and-resume). Rhai is not async.

You have a few choices:

1. Use another scripting language that is async, such as https://github.com/rune-rs

2. Run the script in one thread, the rendering engine in another, using a channel to bind the two (check out the threading example)

3. Move your render loop outside of the script. Call the script during each frame (or spawn a new engine during each frame)

[schungx]

In fact, the scriptable event handler pattern is exactly what you want.

Think about it, you ARE writing an event handler in WASM. The event is render_frame which obviously gets called 60 times a second.

[casey]

That looks great, I didn't see those. Is there an example of the user scripts that go along with the Rust code? I'm assuming the user script would just define start, end, and update functions, like this:

let x = some_initial_state();

fn start() {
}

fn end() {
}

fn update() {
  // can use and mutate `x`
}

[schungx]

There are three actual implementations in the examples folder, one for each scripting style.

[casey]

Awesome, thank you, I'll check those out!

[schungx]

That looks great, I didn't see those. Is there an example of the user scripts that go along with the Rust code? I'm assuming the user script would just define start, end, and update functions, like this:

Usually people like to keep it consistent by having an init function that is called once at the very beginning, and then maybe a finish or destroy function that is called at the very end.

However, if you want to make the global portion of the script a de-facto init function you can also do that, just make sure to disable running the script before each call (otherwise your init function is essentially run each time).