fn translate_original(renderables: &mut Vec<f32>, tx: f32, ty: f32) {
    // This works
    let mut i = 0;
    while i < renderables.len() {
        translate_renderable(renderables, i, tx, ty);
        i = next_renderable(renderables, i);
    }
}

fn translate_iterator(renderables: &mut Vec<f32>, tx: f32, ty: f32) {
    // This fails
    RenderableIterator::new(renderables)
        .for_each(|i| translate_renderable(renderables, i, tx, ty));
}

fn main() {
    let mut data_1: Vec<f32> = vec![
        // renderable 1
        2., 10., 10., 20., 20.,
        // renderable 2
        3., 30., 30., 40., 40., 50., 50.
    ];
    let mut data_2 = data_1.clone();
    translate_original(&mut data_1, 5., 5.);
    translate_iterator(&mut data_2, 5., 5.);
}

fn next_renderable(renderables: &Vec<f32>, i: usize) -> usize {
    i + 1 + (renderables[i] as usize)
}

fn translate_renderable(renderables: &mut Vec<f32>, i: usize, tx: f32, ty: f32) {
    let from = i + 1;
    let to = next_renderable(renderables, i);
    for i in (from..to).step_by(2) {
        renderables[i] += tx;
        renderables[i + 1] += ty;
    }
}

pub struct RenderableIterator<'a> {
    renderables: &'a Vec<f32>,
    i: usize,
}

impl RenderableIterator<'_> {
    pub fn new(renderables: &Vec<f32>) -> RenderableIterator {
        RenderableIterator { renderables, i: 0 }
    }
}

impl Iterator for RenderableIterator<'_> {
    type Item = usize;

    fn next(&mut self) -> Option<usize> {
        if self.i < self.renderables.len() {
            let out = Some(self.i);
            self.i = next_renderable(&self.renderables, self.i);
            out
        } else {
            None
        }
    }
}