Show a map thumbnail for each project in the Open dialog

Saving now grabs a screenshot of the map and stores it in the project, and the
Open dialog renders it as the project's grid image, so projects are
recognisable instead of bare folders (as Lua's screenshot.jpg does).

SaveCommand records a screenshot request (ScreenshotManager); the next
DrawScreen reads the framebuffer -- the only place it is valid -- and writes the
map area (left of the panel) to <project>/sb_project_files/screenshot.jpg via
gfx.save_image. list_assets sets a project directory's image to that file when
it exists. E2E: project_thumbnail.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: gajop

native/src/sbc/panels/controls/grid.rs

@@ -403,10 +403,19 @@ pub(crate) fn list_assets(
         .into_iter()
         .map(|name| {
             let path = join_entry(dir, &name);
+            // A project folder carries a map thumbnail saved on its last save;
+            // show it so projects are recognisable in the Open dialog. Other
+            // directories simply have no such file.
+            let thumb = format!("{path}/sb_project_files/screenshot.jpg");
+            let image = interface
+                .vfs()
+                .file_exists(&thumb)
+                .unwrap_or(false)
+                .then_some(thumb);
             GridItem {
                 id: path,
                 caption: name,
-                image: None,
+                image,
                 is_directory: true,
                 tooltip: None,
                 tooltip_markup: None,

native/src/sbc/project/commands/save_command.rs

@@ -6,6 +6,10 @@ use crate::sbc::command_system::command::Command;
 use crate::sbc::command_system::context::Context;
 use crate::sbc::command_system::registry::register_command;
 use crate::sbc::project::io_registries::save;
+use crate::sbc::project::paths::ProjectPaths;
+use crate::sbc::project::ScreenshotManager;
+
+const SCREENSHOT_FILE: &str = "screenshot.jpg";
 
 #[derive(Deserialize, Debug)]
 pub struct SaveCommand {
@@ -25,7 +29,13 @@ impl SaveCommand {
 
 impl Command for SaveCommand {
     fn execute(&mut self, ctx: &mut Context) {
-        save::save_project(ctx, &PathBuf::from(&self.path), self.is_new_project);
+        let root = PathBuf::from(&self.path);
+        save::save_project(ctx, &root, self.is_new_project);
+        // Grab a fresh map thumbnail for the Open dialog. The framebuffer can
+        // only be read on the draw thread, so record the request and let the
+        // next DrawScreen write it.
+        let path = ProjectPaths::new(&root).file(SCREENSHOT_FILE);
+        ctx.model::<ScreenshotManager>().request(path);
     }
 
     fn undoable(&self) -> bool {

native/src/sbc/project/mod.rs

@@ -10,3 +10,4 @@ mod ui;
 
 pub(crate) use model::project_manager::{ProjectData, ProjectManager};
 pub(crate) use model::scenario_info_manager::{ScenarioInfo, ScenarioInfoManager};
+pub(crate) use model::screenshot_manager::ScreenshotManager;

native/src/sbc/project/model/mod.rs

@@ -1,2 +1,3 @@
 pub mod project_manager;
 pub mod scenario_info_manager;
+pub mod screenshot_manager;

native/src/sbc/project/model/screenshot_manager.rs

@@ -0,0 +1,31 @@
+use std::any::Any;
+use std::path::PathBuf;
+
+use crate::sbc::command_system::model::{Model, ModelFactory};
+
+inventory::submit! { ModelFactory { make: |_iface| Box::new(ScreenshotManager::default()) } }
+
+/// Carries a requested project screenshot from the save command (sim phase) to
+/// the draw phase, where the framebuffer can actually be read. A save asks for
+/// one; the next `DrawScreen` grabs the map and writes it, then clears the
+/// request. Mirrors Lua's `SB.RequestScreenshotPath` consumed in `PerformDraw`.
+#[derive(Default)]
+pub(crate) struct ScreenshotManager {
+    pending: Option<PathBuf>,
+}
+
+impl Model for ScreenshotManager {
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
+impl ScreenshotManager {
+    pub(crate) fn request(&mut self, path: PathBuf) {
+        self.pending = Some(path);
+    }
+
+    pub(crate) fn take(&mut self) -> Option<PathBuf> {
+        self.pending.take()
+    }
+}

native/src/sbc/sbc.rs

@@ -12,6 +12,7 @@ use crate::sbc::devconsole::DevConsoleManager;
 use crate::sbc::io::io_api::IoWorker;
 use crate::sbc::objects::{event_bridge, ObjectKind, ObjectManager, SelectionManager};
 use crate::sbc::panels::PanelManager;
+use crate::sbc::project::ScreenshotManager;
 use crate::sbc::states::StateManager;
 
 const MAX_UNDO_SIZE: usize = 100;
@@ -78,6 +79,7 @@ impl NativeModule for SBC {
     }
 
     fn draw_screen(&mut self) -> Result<(), Error> {
+        self.capture_pending_screenshot();
         self.model::<StateManager>().draw_screen();
         self.model::<ChonsoleManager>().draw_screen()?;
         self.model::<PanelManager>().draw_screen()
@@ -238,6 +240,36 @@ impl SBC {
         &self.interface
     }
 
+    /// Write a requested project thumbnail: the map area (left of the panel) of
+    /// the current frame. Read at the top of DrawScreen, before the panel or any
+    /// overlay is drawn over the map, since the framebuffer is only readable on
+    /// the draw thread.
+    fn capture_pending_screenshot(&mut self) {
+        let Some(path) = self.model::<ScreenshotManager>().take() else {
+            return;
+        };
+        let Ok(geom) = self.interface.display().get_view_geometry() else {
+            return;
+        };
+        const PANEL_WIDTH: i32 = 500;
+        let width = (geom.viewSizeX - PANEL_WIDTH).max(1);
+        if let Some(parent) = path.parent() {
+            let _ = std::fs::create_dir_all(parent);
+        }
+        // yflip: glReadPixels is bottom-origin; flip to top-origin image space.
+        let _ = self.interface.gfx().save_image(
+            0,
+            0,
+            width,
+            geom.viewSizeY,
+            &path.to_string_lossy(),
+            false,
+            true,
+            false,
+            0,
+        );
+    }
+
     /// Apply any finished background-IO outcomes on the engine thread. Called
     /// each tick; also driven by the in-engine tests while they block the tick.
     pub(crate) fn drain_io(&mut self) {

tools/e2e/scenarios/gallery.py

@@ -426,6 +426,26 @@ def project_save_as(run_state: E2ERun) -> None:
     run_state.screenshot("after-reload")
 
 
+@scenario()
+def project_thumbnail(run_state: E2ERun) -> None:
+    """Saving captures a map thumbnail that the Open dialog shows.
+
+    Save As saves the project (grabbing a screenshot of the map on the draw
+    after the save) and reloads into it; the Open dialog then renders that
+    screenshot as the project's grid image instead of a bare folder.
+    """
+    left = panel_left(run_state)
+    run_state.focus()
+    run_state.click(*panel_point(left, TOOLBAR["save_as"]), delay=1.0)
+    run_state.click(*dialog_point(run_state, DIALOG["file_name"]), delay=0.3)
+    run_state.type_text("ShotProj")
+    run_state.key("Return", delay=0.3)
+    run_state.click(*dialog_point(run_state, DIALOG["file_ok_name"]), delay=6.0)
+    # Open the project list; the saved project shows its map thumbnail.
+    run_state.click(*panel_point(left, TOOLBAR["load"]), delay=2.0)
+    run_state.screenshot("open-with-thumbnail")
+
+
 @scenario()
 def large_map_create(run_state: E2ERun) -> None:
     """Create the largest map the dialog allows (32x32) and boot into it.