Example of using pollock.rs to make some simple sketches

pollock.rs

#![feature(nll)]

#[macro_use]
extern crate pollock;
extern crate serde;
#[macro_use]
extern crate serde_derive;

use pollock::*;

#[derive(Serialize, Deserialize)]
struct State {
    balls: Vec<(V2, V2)>,
}

fn spinning_dots() {
    let radius = 300.;
    let max_size = 7.;
    Pollock::setup(|p| {
        p.size = (600, 600);
        p.background = rgb(0, 0, 0);
        p.stroke = Stroke::none();
        p.fill = Fill::new(rgb(200, 0, 0));
    }).draw(|p| {
        let angle_steps = 40;
        let radius_steps = 20;

        let origin = v2(p.width() / 2, p.height() / 2);
        let angle_step = 2. * consts::PI / angle_steps as f64;

        p.stroke = Stroke::none();
        p.circle(origin, max_size);
        for i in 0..angle_steps {
            let angle = i as f64 * angle_step;
            for j in 0..radius_steps {
                let dist_step = if i % 2 == 0 { 0.5 } else { 0. };

                let step = j as f64 + dist_step;

                let perc = (((p.frame_count as f64 / 100.) + step) / radius_steps as f64) % 1.;
                let scaled_perc = 1. - (1. - perc).powi(3);
                let angle = perc + angle;
                let dist = scaled_perc * radius;

                let size = (((1. - scaled_perc) + 0.75).min(1.).sqrt() - 0.75f64.sqrt()) * 4.;

                let (s, c) = (angle.sin(), angle.cos());
                p.with_fill(Fill::new(rgb(60, 0, 0)))
                    .circle(origin + v2(dist * s, dist * c), size * max_size);
            }
        }

        for i in 0..angle_steps {
            let angle = i as f64 * angle_step;
            for j in 0..radius_steps {
                let dist_step = if i % 2 == 0 { 0.5 } else { 0. };

                let step = j as f64 + dist_step;

                let perc = (((p.frame_count as f64 / 100.) + step) / radius_steps as f64) % 1.;
                let scaled_perc = 1. - (1. - perc).powi(3);
                let angle = perc + angle;
                let dist = scaled_perc * radius;

                let size = (((1. - scaled_perc) + 0.75).min(1.).sqrt() - 0.75f64.sqrt()) * 4.;

                let (s, c) = (angle.sin(), angle.cos());
                let dist = (1. - scaled_perc) * radius;
                let size = ((scaled_perc + 0.75).min(1.).sqrt() - 0.75f64.sqrt()) * 4.;
                p.circle(origin + v2(dist * s, dist * c), size * max_size);
            }
        }
    }).on_frame(200, |p| p.start_recording())
    .on_frame(300, |p| p.stop_recording("recording.gif"))
    .run()
}

fn bouncing_balls() {
    let radius = 50.;

    Pollock::setup(|p| {
        p.size = (600, 600);
        p.background = Color::new(255, 255, 255, 255);
        p.stroke = Stroke::new(rgb(0, 0, 0), 2);
        p.fill = Fill::new(rgba(0, 0, 0, 0));

        State {
            balls: (0..100)
                .map(|_| {
                    (
                        v2(
                            p.random_range(0., p.width() as f64),
                            p.random_range(0., p.height() as f64),
                        ),
                        v2(
                            if p.random() { -1 } else { 1 },
                            if p.random() { -1 } else { 1 },
                        ),
                    )
                }).collect(),
        }
    }).update(|p| {
        let (width, height) = p.size;
        for (pos, vel) in &mut p.state.balls {
            if pos.x < radius {
                vel.x = 1.
            } else if pos.x > width as f64 - radius {
                vel.x = -1.
            }

            if pos.y < radius {
                vel.y = 1.
            } else if pos.y > height as f64 - radius {
                vel.y = -1.
            }

            *pos += *vel * 1.;
        }
    }).draw(|p| {
        for (i, (pos, _)) in p.state.balls.iter().enumerate() {
            let (r, g, b) = (
                (((p.frame_count as f64 + i as f64) * consts::PI / 60.).sin() + 1.) * 255. / 2.,
                (((p.frame_count as f64 + 20. + i as f64) * consts::PI / 60.).sin() + 1.) * 255.
                    / 2.,
                (((p.frame_count as f64 + 40. + i as f64) * consts::PI / 60.).sin() + 1.) * 255.
                    / 2.,
            );

            p.with_stroke(Stroke::new(rgb(r as u8, g as u8, b as u8), 5))
                .circle(*pos, radius);
        }
    }).hot_reload()
    .on_key_down(Key::E, |p| p.fill = Fill::new(rgb(255, 0, 0)))
    .on_key_down(Key::F, |p| p.fill = Fill::new(rgb(0, 255, 0)))
    .on_key_down(Key::O, |p| p.start_recording())
    .on_key_down(Key::P, |p| p.stop_recording("out_gif"))
    .on_key_down(Key::Q, |p| p.save_image("out"))
    .on_key_down(Key::Space, |p| p.paused = !p.paused)
    .run();
}

fn polkadot() {
    #[derive(Serialize, Deserialize)]
    struct State {
        time: f64,
        gt: f64,
        ex: i32,
        ey: i32,
        wl: f64,
    }

    let ease = |p| {
        let pe = 3. * p * p - 2. * p * p * p;
        let pe = 3. * pe * pe - 2. * pe * pe * pe;

        3. * pe * pe - 2. * pe * pe * pe
    };

    let v = 0.0001;

    let n = 12;
    let mn = 3f64.sqrt() / 2.;
    let size = (900, 600);
    let sp = size.0 as f64 / 12.;
    let d = sp * 0.5;
    let fps = 20;

    Pollock::setup(|p| {
        p.size = size;
        p.fill = Fill::new(rgb(200, 200, 200));
        p.background = rgb(255, 255, 255);
        p.stroke = Stroke::none();

        State {
            time: 0.,
            gt: 0.,
            ex: 0,
            ey: 0,
            wl: 0.,
        }
    }).update(|p| {
        let gt = v * fps as f64 * p.frame_count as f64;
        let previous_time = p.state.time;
      
        p.state.gt = gt;
        p.state.time = gt % 1.;
        p.state.wl = 4. * (consts::PI * 2. * gt / 6.).cos() / 100.;
    }).draw(|p| {
        let sp = sp * 2f64.powf(p.state.time);
        let structure = -(consts::PI * 2. * p.state.gt / 6.).cos();
        let structure = ease(structure.max(0.).min(1.));

        for i in -n..n {
            for j in -n..n {
                let mut x = i as f64 * sp;
                let y = j as f64 * mn * sp;
                if j % 2 != 0 {
                    x += 0.5 * sp;
                }

                if x.abs() < p.width() as f64 * 0.65 && y.abs() < p.height() as f64 * 0.65 {
                    let r = v2(x, y).magnitude();

                    let tt = (7. * p.state.time
                        - 0.0045 * (v2(x, y) - v2(p.state.ex, p.state.ey)).magnitude()).max(0.)
                    .min(1.);
                    let tt = ease(tt);

                    let dd = if j % 2 == 0 && (i + j / 2) % 2 == 0 {
                        d
                    } else {
                        d * tt
                    };

                    let wl = p.state.wl;
                    let ph = (wl * x).cos()
                        * (wl * (0.5 * x + mn * y)).cos()
                        * (wl * (0.5 * x - mn * y)).cos();
                    let ph = ph.max(0.).min(1.);

                    let factor = 1. - structure;
                    let (low, high) = (1., ph);

                    let (hw, hh) = (p.width() as f64 / 2., p.height() as f64 / 2.);
                    p.ellipse(v2(x + hw, y + hh), dd, dd);
                }
            }
        }
    }).hot_reload()
    .on_key_down(Key::O, |p| p.start_recording())
    .on_key_down(Key::P, |p| p.stop_recording("out_gif"))
    .on_frame((1. / (v * fps as f64)) as _, |p| p.start_recording())
    .on_frame((2. / (v * fps as f64)) as _, |p| {
        p.stop_recording("recording.gif")
    }).run()
}