curve: CubicCurve<Vec3>,

    pub curve: CubicCurve<Vec3>,

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

#[derive(Debug, Clone, Copy)]

    Ring,

    Ring { position: Vec3, look_at: Vec3 },

    let ring = assets.load("Ring.glb#Scene0");

        if model[x][y][z] == Cube::Empty {
            rocks_ct -= 1;
            model[x][y][z] = Cube::Rock;

        match model[x][y][z] {
            Cube::Empty => {
                rocks_ct -= 1;
                model[x][y][z] = Cube::Rock;
            }
            _ => (),

        let p2 = point.clone();
        model[((p2.x / 10.0).round() + 4.5) as usize][((p2.y / 10.0).round() + 4.5) as usize]
            [((p2.z / 10.0).round() + 4.5) as usize] = Cube::Ring;

    let track = Track::new(curve_points, 1.0, 16, 200);
    for t in 0..10 {
        let t = t as f32;
        let p2 = track.curve.position(t);
        model[((p2.x / 20.0).round() + 4.5) as usize][((p2.y / 20.0).round() + 4.5) as usize]
            [((p2.z / 20.0).round() + 4.5) as usize] = Cube::Ring {
            position: p2.clone(),
            look_at: track.curve.velocity(t).normalize(),
        };
    }

                if model[i][j][k] == Cube::Rock {
                    commands.spawn(SceneBundle {
                        scene: rock.clone(),
                        transform: Transform::from_xyz(
                            (-5.0 + i as f32) * 20.0,
                            (-5.0 + j as f32) * 20.0,
                            (-5.0 + k as f32) * 20.0,
                        )
                        .with_scale(r.gen::<f32>() * Vec3::splat(3.0)),
                        ..default()
                    });
                }

                match model[i][j][k] {
                    Cube::Rock => {
                        commands.spawn(SceneBundle {
                            scene: rock.clone(),
                            transform: Transform::from_xyz(
                                (-4.5 + i as f32) * 20.0,
                                (-4.5 + j as f32) * 20.0,
                                (-4.5 + k as f32) * 20.0,
                            ), //.with_scale(r.gen::<f32>() * Vec3::splat(3.0)),
                            ..default()
                        });
                    }
                    Cube::Ring { position, look_at } => {
                        commands.spawn(SceneBundle {
                            scene: ring.clone(),
                            transform: Transform::from_xyz(position.x, position.y, position.z)
                                .looking_to(look_at, Vec3::ZERO)
                                .with_scale(Vec3::splat(3.0)),
                            ..default()
                        });
                    }
                    Cube::Empty => (),
                };

    let track = Track::new(curve_points, 1.0, 16, 200);