Slow animation with Nannou - rust

Question

I'm trying to learn Rust and Nannou, and I'm confused why this animation is so slow with only 1000 elements. I was hoping generating animations in Rust would be lighting fast, but not off to a great start.
use nannou::prelude::*;
fn main() {
nannou::app(model).update(update).simple_window(view).run();
}
struct Model {
particles: Vec<f32>,
}
fn model(_app: &App) -> Model {
let n_particles = 1000;
let mut particles: Vec<f32> = vec![];
for idx in 0..n_particles {
particles.push(map_range(idx, 0, n_particles, 0.0, 1.0));
}
Model { particles }
}
fn update(_app: &App, model: &mut Model, _update: Update) {}
fn view(app: &App, model: &Model, frame: Frame) {
// Prepare to draw.
let draw = app.draw();
// Get boundary of the window (to constrain the movements of our circle)
let boundary = app.window_rect();
// Clear the background to purple.
draw.background().color(PLUM);
for idx in 0..model.particles.len() {
let particle = &model.particles[idx];
let sine = app.time.sin() * particle;
let slowersine = (app.time / 2.0).sin() * particle;
// Map the sine wave functions to ranges between the boundaries of the window
let x = map_range(sine, -1.0, 1.0, boundary.left(), boundary.right());
let y = map_range(slowersine, -1.0, 1.0, boundary.bottom(), boundary.top());
// Draw a blue ellipse at the x/y coordinates 0.0, 0.0
draw.ellipse().color(STEELBLUE).x_y(x, y).radius(10.0);
}
// Generate sine wave data based on the time of the app
draw.to_frame(app, &frame).unwrap();
}

Answer 1

I do not think your code is doing what you are expecting. The use of "particle" in the view function seems superfluous when it is ultimately only being used to affect the x and y values passed to the x_y function.
Running your code as-is gave me an unexpected result: It looked like the ellipse was rendered multiple times creating an animated line waving around the screen. Commenting out several lines and removing "* particle" from the "sine" and "slowersine" assignments resulted in an ellipse moving around the window smoothly.
Note: Several warnings are generated due to unused variables now.
Updated code:
use nannou::prelude::*;
fn main() {
nannou::app(model).update(update).simple_window(view).run();
}
struct Model {
particles: Vec<f32>,
}
fn model(_app: &App) -> Model {
let n_particles = 1000;
let mut particles: Vec<f32> = vec![];
for idx in 0..n_particles {
particles.push(map_range(idx, 0, n_particles, 0.0, 1.0));
}
Model { particles }
}
fn update(_app: &App, model: &mut Model, _update: Update) {}
fn view(app: &App, model: &Model, frame: Frame) {
// Prepare to draw.
let draw = app.draw();
// Get boundary of the window (to constrain the movements of our circle)
let boundary = app.window_rect();
// Clear the background to purple.
draw.background().color(PLUM);
// for idx in 0..model.particles.len() {
// let particle = &model.particles[idx];
// let sine = app.time.sin() * particle;
// let slowersine = (app.time / 2.0).sin() * particle;
let sine = app.time.sin();
let slowersine = (app.time / 2.0).sin();
// Map the sine wave functions to ranges between the boundaries of the window
let x = map_range(sine, -1.0, 1.0, boundary.left(), boundary.right());
let y = map_range(slowersine, -1.0, 1.0, boundary.bottom(), boundary.top());
// Draw a blue ellipse at the x/y coordinates 0.0, 0.0
draw.ellipse().color(STEELBLUE).x_y(x, y).radius(10.0);
// }
// Generate sine wave data based on the time of the app
draw.to_frame(app, &frame).unwrap();
}