Sierpinsky triangles in Rust using Nannou

sierpinsky.rs

use nannou::prelude::*;

fn main() {
    nannou::app(model).update(update).run();
}

struct Triangle {
    top: Point2<f32>,
    left: Point2<f32>,
    right: Point2<f32>,
}

struct Model {
    _window: window::Id,
    triangles: Vec<Triangle>,
}

fn init_triangles(app: &App) -> Vec<Triangle> {
    let win = app.window_rect();
    let h = win.h() / 2.0;
    let w = win.w() / 2.0;

    let top = pt2(0.0, h);
    let left = pt2(-w, -h);
    let right = pt2(w, -h);

    return vec![Triangle { top, left, right }];
}

fn model(app: &App) -> Model {
    let _window = app
        .new_window()
        .with_dimensions(1200, 1200)
        .view(view)
        .event(window_event)
        .build()
        .unwrap();

    let triangles = init_triangles(app);

    return Model { _window, triangles };
}

fn compute_triangles(triangles : &Vec<Triangle>) -> Vec<Triangle> {
    let mut v = vec![];
    
    for triangle in triangles {
        let mid_left_x   = (triangle.top.x  + triangle.left.x ) / 2.0;
        let mid_left_y   = (triangle.top.y  + triangle.left.y ) / 2.0;
        let mid_bottom_x = (triangle.left.x + triangle.right.x) / 2.0;
        let mid_bottom_y = (triangle.left.y + triangle.right.y) / 2.0;
        let mid_right_x  = (triangle.top.x + triangle.right.x) / 2.0;
        let mid_right_y  = (triangle.top.y + triangle.right.y) / 2.0;

        let triangle1 = Triangle {
            top: pt2(mid_left_x, mid_left_y),
            left: triangle.left,
            right: pt2(mid_bottom_x, mid_bottom_y),
        };

        let triangle2 = Triangle {
            top: pt2(mid_right_x, mid_right_y),
            left : pt2(mid_bottom_x, mid_bottom_y),
            right: triangle.right,
        };

        let triangle3 = Triangle {
            top: triangle.top,
            left: pt2(mid_left_x, mid_left_y),
            right: pt2(mid_right_x, mid_right_y),
        };

        v.push(triangle1);
        v.push(triangle2);
        v.push(triangle3);
    }
    return v;
}

fn update(_app: &App, model: &mut Model, _update: Update) { }

fn window_event(_app: &App, model: &mut Model, event: WindowEvent) {
    match event {
        KeyPressed(_key) => {}
        KeyReleased(_key) => {}
        MouseMoved(_pos) => {}
        MousePressed(_button) => {
            if model.triangles.len() < 9000 {
                model.triangles = compute_triangles(&model.triangles)
            } else {
                model.triangles = init_triangles(_app);
            }
        }
        MouseReleased(_button) => {}
        MouseEntered => {}
        MouseExited => {}
        MouseWheel(_amount, _phase) => {}
        Moved(_pos) => {}
        Resized(_size) => {}
        Touch(_touch) => {}
        TouchPressure(_pressure) => {}
        HoveredFile(_path) => {}
        DroppedFile(_path) => {}
        HoveredFileCancelled => {}
        Focused => {}
        Unfocused => {}
        Closed => {}
    }
}

fn view(app: &App, _model: &Model, frame: &Frame) {
    let draw = app.draw();

    draw.background().color(WHITE);

    for triangle in &_model.triangles {
        draw.tri()
            .points(triangle.top, triangle.left, triangle.right)
            .stroke(ORANGE)
            .stroke_weight(0.5)
            .color(GOLD);
    }

    draw.to_frame(app, &frame).unwrap();
}