donut.c converted to donut.rs (Rust)

 I tried to convert Andy Sloane's donut.c to Rust programming language. Suggestions are welcome.

//
// donut -- rotating donut
//
// note: ported a C version by CJKim - July 9, 2024
//
// the original C version's author is Andy Sloane
//

use std::{env, thread, time::Duration};
use getopts::Options;

fn donut(delay: u64) {
    const GRIDSIZE: usize = 1760;
    const TEXTURE: [char; 12] = ['.',',','-','~', ':', ';', '=', '!', '*', '#', '$', '@'];
    let mut rot_a: f32 = 0.0;
    let mut rot_b: f32 = 0.0;

    let mut iter: usize = 0;
    loop {
        iter += 1;
        let mut z: [f32;  GRIDSIZE] = [0.0; GRIDSIZE];
        let mut b: [char; GRIDSIZE] = [' '; GRIDSIZE];
        let mut grid = b.clone();
        let mut j: f32 = 0.0;
        while j < 6.28 {
            let mut i: f32 = 0.0;
            while i < 6.28 {
                let c: f32 = i.sin();
                let d: f32 = j.cos();
                let e: f32 = rot_a.sin();
                let f: f32 = j.sin();
                let g: f32 = rot_a.cos();
                let h: f32 = d + 2.0;
                let deg: f32 = 1.0 / (c * h * e + f * g + 5.0);
                let l: f32 = i.cos();
                let m: f32 = rot_b.cos();
                let n: f32 = rot_b.sin();
                let t: f32 = c * h * g - f * e;
                let x = (40.0 + 30.0 * deg * (l * h * m - t * n)) as i32;
                let y = (12.0 + 15.0 * deg * (l * h * n + t * m)) as i32;
                let o = (x + 80 * y) as usize;
                let idx: usize = (8.0 * ((f * e - c * d * g) * m
                                - c * d * e - f * g - l * d * n)) as usize;
                if 22 > y && y > 0 && x > 0 && 80 > x && deg > z[o as usize] {
                    z[o] = deg;
                    let pidx: usize = if idx > 0 { idx } else { 0 };
                    b[o] = TEXTURE[pidx];
                }
                i += 0.02;
            }
            j += 0.07;
        }
        for k in 0..GRIDSIZE {
            // putchar(k % 80 ? b[k] : 10);
            let chr = if k % 80 == 0 { '\n' } else { b[k as usize] };
            grid[k as usize] = chr;
            rot_a += 0.00004;
            rot_b += 0.00002;
        }
        let ostr = String::from_iter(grid);     // convert chars to a string
                println!("\x1b[H{}\n{}", ostr, iter);
        // BUG: when rot_a reaches 1024 and rot_b 512, the donut no longer spins
        if rot_a > 1000.0 || rot_b > 500.0 {
            rot_a = 0.0;
            rot_b = 0.0;
        }
        thread::sleep(Duration::from_millis(delay));
    }
}

fn print_usage(prgnam: &str, opts: Options) {
    let usage = format!("usage: {} [options]", prgnam);
    println!("{}", opts.usage(&usage));
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let prognam = args[0].clone();
    let mut opts = Options::new();
    opts.optopt("d", "delay", "number of milliseconds between iterations (default=30)", "milsecs");
    opts.optflag("h", "help", "print this help message and exit");
    let matches = match opts.parse(&args[1..]) {
        Ok(m)  => { m }
        Err(e) => {
            println!("{}", e.to_string());
            print_usage(&prognam, opts);
            return;
        }
    };
    if matches.opt_present("h") {
        print_usage(&prognam, opts);
        return;
    }
    let delay: u64 = match matches.opt_str("d") {
        Some(m) => {
            match m.parse() {
                Ok(x)  => { x }
                Err(e) => {
                    println!("{} - {}", "bad milliseconds specified", e);
                    print_usage(&prognam, opts);
                    return;
                }
            }
        }
        _ => { 30 as u64 }
    };
    print!("\x1b[2J\x1b[HHello, donut lovers! [Hit ^C to stop it.]");
    donut(delay);
}