使用rust绘制具有第三列值的颜色的2D地图

use ggez::{Context, GameResult};
use ggez::event::{self, EventHandler};
use ggez::graphics::{self, Color, DrawMode, Rect};
use ggez::nalgebra as na;

const MAP_WIDTH: usize = 10;
const MAP_HEIGHT: usize = 10;

struct Map {
    data: [[f32; 3]; MAP_WIDTH * MAP_HEIGHT],
}

impl Map {
    fn new() -> Map {
        Map {
            data: [[0.0; 3]; MAP_WIDTH * MAP_HEIGHT],
        }
    }
}

struct MainState {
    map: Map,
}

impl MainState {
    fn new() -> GameResult<MainState> {
        let map = Map::new();
        Ok(MainState { map })
    }
}

impl EventHandler for MainState {
    fn update(&mut self, _ctx: &mut Context) -> GameResult {
        // 更新地图数据
        // 这里可以根据需要更新地图数据，例如模拟地图的变化等
        Ok(())
    }

    fn draw(&mut self, ctx: &mut Context) -> GameResult {
        graphics::clear(ctx, Color::BLACK);

        let cell_width = graphics::screen_coordinates(ctx).w / MAP_WIDTH as f32;
        let cell_height = graphics::screen_coordinates(ctx).h / MAP_HEIGHT as f32;

        for y in 0..MAP_HEIGHT {
            for x in 0..MAP_WIDTH {
                let rect = Rect::new(
                    x as f32 * cell_width,
                    y as f32 * cell_height,
                    cell_width,
                    cell_height,
                );

                let color = Color::new(
                    self.map.data[y * MAP_WIDTH + x][0],
                    self.map.data[y * MAP_WIDTH + x][1],
                    self.map.data[y * MAP_WIDTH + x][2],
                    1.0,
                );

                let mesh = graphics::Mesh::new_rectangle(ctx, DrawMode::fill(), rect, color)?;
                graphics::draw(ctx, &mesh, (na::Point2::new(0.0, 0.0),))?;
            }
        }

        graphics::present(ctx)?;
        Ok(())
    }
}

fn main() -> GameResult {
    let mut cb = ggez::ContextBuilder::new("rust_map", "ggez")
        .window_setup(ggez::conf::WindowSetup::default().title("Rust Map"))
        .window_mode(ggez::conf::WindowMode::default().dimensions(800.0, 600.0));
    let (ctx, event_loop) = &mut cb.build()?;
    let state = &mut MainState::new()?;
    event::run(ctx, event_loop, state)
}