Fix map export round trip

Author: gajop

native/src/sbc/textures/ops/export.rs

@@ -28,8 +28,12 @@ pub(crate) fn export_diffuse(
             let texture = surface.borrow().texture.clone();
             let x1 = -1.0 + 2.0 * (i * tile_size) as f32 / width as f32;
             let x2 = -1.0 + 2.0 * ((i + 1) * tile_size) as f32 / width as f32;
-            let y1 = -1.0 + 2.0 * ((tiles_z - j) * tile_size) as f32 / height as f32;
-            let y2 = -1.0 + 2.0 * ((tiles_z - j + 1) * tile_size) as f32 / height as f32;
+            // `save_texture_png` flips the framebuffer rows while reading them
+            // into the top-down PNG consumed by mapcompile.  Keep the engine's
+            // tile rows in their native order here; reversing them as well
+            // mirrors painted diffuse texture across the map on export.
+            let y1 = -1.0 + 2.0 * (j * tile_size) as f32 / height as f32;
+            let y2 = -1.0 + 2.0 * ((j + 1) * tile_size) as f32 / height as f32;
             let _ = gfx.bind_texture(&texture, 0, true);
             let _ = gfx.tex_rect(x1, y1, x2, y2, 0.0, 0.0, 1.0, 1.0);
             let _ = gfx.bind_texture(&texture, 0, false);

tools/e2e/run_commands.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import time
 
 from run_env import command_fields
 
@@ -28,6 +29,64 @@ def engine_log(self) -> list[str]:
             return []
         return path.read_text(errors="replace").splitlines()
 
+    def log_cursor(self) -> int:
+        """A position in the engine log that can be passed to ``wait_for_log``.
+
+        Reloading a project starts a new game in the same process, so its ready
+        line occurs more than once.  Capturing a cursor lets a scenario wait
+        for the *next* occurrence instead of sleeping for a guessed duration.
+        """
+        return len(self.engine_log())
+
+    def wait_for_log(self, text: str, *, after: int = 0, timeout_s: float = 15.0) -> str:
+        """Wait until a newly written engine-log line contains ``text``.
+
+        The process is checked on every poll, which turns a reload crash into a
+        useful immediate error rather than an arbitrary timeout.
+        """
+        deadline = time.monotonic() + timeout_s
+        while time.monotonic() < deadline:
+            for line in self.engine_log()[after:]:
+                if text in line:
+                    self.event("wait_for_log", text=text, line=line)
+                    return line
+            self.assert_running()
+            time.sleep(0.05)
+        raise AssertionError(f"timed out waiting {timeout_s:.1f}s for log line containing {text!r}")
+
+    def wait_for_command(
+        self,
+        class_name: str,
+        *,
+        after: int = 0,
+        timeout_s: float = 10.0,
+        **expected: object,
+    ) -> dict:
+        """Wait for a committed command, optionally matching fields.
+
+        This is for asynchronous UI paths such as modal acceptance.  Unlike an
+        assertion, it returns as soon as the command bridge records the event.
+        """
+        deadline = time.monotonic() + timeout_s
+        while time.monotonic() < deadline:
+            for entry in self.commands()[after:]:
+                data = entry.get("data", {})
+                if data.get("__preview") or data.get("className") != class_name:
+                    continue
+                fields = command_fields(data)
+                if all(
+                    key in fields
+                    and (want(fields[key]) if callable(want) else fields[key] == want)
+                    for key, want in expected.items()
+                ):
+                    self.event("wait_for_command", className=class_name, keys=sorted(expected))
+                    return data
+            self.assert_running()
+            time.sleep(0.05)
+        raise AssertionError(
+            f"timed out waiting {timeout_s:.1f}s for {class_name} with keys {sorted(expected)}"
+        )
+
     def commands(self) -> list[dict]:
         """Every command envelope the UI sent to the command bridge.
 
@@ -53,6 +112,10 @@ def commands(self) -> list[dict]:
                     entries.append({**entry, "data": inner})
         return entries
 
+    def command_cursor(self) -> int:
+        """A position in the command log for ``wait_for_command(after=...)``."""
+        return len(self.commands())
+
     def assert_command(self, class_name: str, **expected: object) -> dict:
         """Assert exactly one committed command of `class_name` carrying every
         key in `expected` was sent, and that those values match.

tools/e2e/run_input.py

@@ -113,6 +113,23 @@ def click(self, x: int, y: int, button: int = 1, delay: float = 0.08) -> None:
         )
         nap(delay)
 
+    def click_settled(self, x: int, y: int, button: int = 1, delay: float = 0.08) -> None:
+        """Click after one engine input tick at the target position.
+
+        Most controls accept a compact ``click``. A toolbar action immediately
+        after map editing can otherwise be hit-tested at the previous map
+        position, so a scenario can opt into this precise move/press sequence
+        instead of sleeping on a guessed UI transition.
+        """
+        self.require_window()
+        self.event("click_settled", x=x, y=y, button=button)
+        run("xdotool", "mousemove", "--window", self.window, str(x), str(y))
+        time.sleep(SETTLE)
+        run("xdotool", "mousedown", str(button))
+        nap(0.03)
+        run("xdotool", "mouseup", str(button))
+        nap(delay)
+
     def move(self, x: int, y: int, delay: float = 0.08) -> None:
         self.require_window()
         self.event("move", x=x, y=y)

tools/e2e/scenarios/geometry.py

@@ -222,15 +222,18 @@
 # action order is UI presentation, while e2e scenarios care about the command
 # being invoked.  Centres are measured in the running Rust panel.
 TOOLBAR: Final = {
-    "new_project": (34, 165),
-    "load": (74, 165),
-    "import": (114, 165),
-    "save": (154, 165),
-    "save_as": (194, 165),
-    "export": (234, 165),
-    "copy": (274, 165),
-    "cut": (314, 165),
-    "paste": (354, 165),
+    # .action-bar has 5dp left padding, 38dp buttons, and 1dp gaps.
+    # Keep clicks at the centres; the former coordinates grazed the right edge
+    # and were intermittently lost by RmlUi.
+    "new_project": (24, 165),
+    "load": (63, 165),
+    "import": (102, 165),
+    "save": (141, 165),
+    "save_as": (180, 165),
+    "export": (219, 165),
+    "copy": (258, 165),
+    "cut": (297, 165),
+    "paste": (336, 165),
 }
 
 # Modal controls are offsets from `dialog_left()`, not fixed screen positions.

tools/e2e/scenarios/map.py

@@ -167,7 +167,9 @@ def stroke(x: int, y: int, dx: int, dy: int) -> None:
     # stroke is plainly visible in `stroke-*.png` and the diffs mean something.
     run_state.wheel(width // 3, height // 2, clicks=ZOOM_CLICKS, up=True, delay=0.5)
     click_field(run_state, left, MAP["terrain_size"], "400")
-    click_field(run_state, left, MAP["terrain_strength"], "8")
+    # Shape Modify applies a signed delta, so Strength controls a visible
+    # relief; Height remains meaningful only when the Level brush follows.
+    click_field(run_state, left, MAP["terrain_strength"], "1000")
     click_field(run_state, left, MAP["terrain_height"], "80")
     run_state.screenshot("brush-settings")
 
@@ -616,21 +618,23 @@ def map_export(run_state: E2ERun) -> None:
     width, height = window_size(run_state)
 
     # A project first: Export compiles the *saved* project, so it needs a path.
-    # Save As creates it and reloads into it (the one unavoidable wait).
-    run_state.click(*panel_point(left, TOOLBAR["save_as"]), delay=0.6)
-    run_state.click(*dialog_point(run_state, DIALOG["file_name"]), delay=0.15)
+    # Save As creates it and reloads into it. Wait for the second ready line,
+    # rather than assuming every machine needs the old fixed eight seconds.
+    reload_log = run_state.log_cursor()
+    run_state.click_settled(*panel_point(left, TOOLBAR["save_as"]), delay=0.3)
+    run_state.click_settled(*dialog_point(run_state, DIALOG["file_name"]), delay=0.1)
     run_state.type_text("ExportMap")
-    run_state.key("Return", delay=0.15)
-    # The one unavoidable wait: Save As restarts the engine into the new project.
-    run_state.click(*dialog_point(run_state, DIALOG["file_ok_name"]), delay=8.0)
+    run_state.click_settled(*dialog_point(run_state, DIALOG["file_ok_name"]), delay=0.1)
+    run_state.wait_for_command("ReloadIntoProjectCommand")
+    run_state.wait_for_log("finished loading and is now ingame", after=reload_log)
 
     # Terrain: pick a pattern, arm Add, a fat brush, one sweep across the map.
     run_state.click(left + TAB_X["map"], TAB_Y, delay=0.15)
     run_state.click(*editor_point(left, "map", "terrain"), delay=0.3)
     run_state.click(*panel_point(left, MAP["terrain_pattern"]), delay=0.15)
     run_state.click(*panel_point(left, MAP_ACTIONS["terrain_add"]), delay=0.15)
     click_field(run_state, left, MAP["terrain_size"], "1200")
-    click_field(run_state, left, MAP["terrain_height"], "80")
+    click_field(run_state, left, MAP["terrain_strength"], "1000")
     _sweep(run_state, left, width, height)
     run_state.assert_command_at_least("TerrainShapeModifyCommand", 1)
 
@@ -642,15 +646,20 @@ def map_export(run_state: E2ERun) -> None:
     run_state.click(*panel_point(left, MAP_ACTIONS["texture_paint"]), delay=0.15)
     _sweep(run_state, left, width, height)
     run_state.assert_any_command("TerrainChangeTextureCommand", paintMode="paint")
+    run_state.key("Escape", delay=0.15)
+    run_state.move(*panel_point(left, PARK_PANEL), delay=0.15)
+    edited = run_state.screenshot("edited-before-export")
 
     # Save the edits, then Export -> Spring archive (the default type).
+    save_log = run_state.log_cursor()
     run_state.key("ctrl+s", delay=0.5)
     run_state.assert_command_at_least("SaveCommand", 1)
-    run_state.click(*panel_point(left, TOOLBAR["export"]), delay=0.3)
-    run_state.click(*dialog_point(run_state, DIALOG["file_name"]), delay=0.15)
+    run_state.wait_for_log("save editor state:", after=save_log)
+    run_state.click_settled(*panel_point(left, TOOLBAR["export"]), delay=0.2)
+    run_state.click_settled(*dialog_point(run_state, DIALOG["file_name"]), delay=0.1)
     run_state.type_text("ExportMap")
-    run_state.key("Return", delay=0.15)
-    run_state.click(*dialog_point(run_state, DIALOG["file_ok_export"]), delay=0.3)
+    run_state.click_settled(*dialog_point(run_state, DIALOG["file_ok_export"]), delay=0.1)
+    run_state.wait_for_command("ExportSpringArchiveCommand")
     run_state.assert_command("ExportSpringArchiveCommand")
 
     archive = _wait_for_archive(run_state, "ExportMap")
@@ -659,6 +668,49 @@ def map_export(run_state: E2ERun) -> None:
     if archive.stat().st_size < 1024:
         raise AssertionError(f"compiled archive is suspiciously small: {archive}")
 
+    # Prove the deliverable is usable: expose this session's archive to the map
+    # scanner, create a project on it, and check that the painted material is
+    # still visibly present.  Comparing camera frames pixel-for-pixel here is
+    # deliberately avoided: reloading rebuilds the terrain draw and its
+    # sub-pixel shading is not frame-stable, even when the exported texture is.
+    # `tiles` is orange while the base map is green, so this is a direct visual
+    # assertion that the diffuse PNG made it through mapcompile and back in.
+    map_region = (left // 2 - 260, height // 2 - 220, 520, 440)
+    painted_before = run_state.count_color(edited, map_region, "#C87830", fuzz="18%")
+    if painted_before < 5_000:
+        raise AssertionError(
+            f"texture paint was not visibly present before export ({painted_before} warm pixels)"
+        )
+    assert run_state.write_dir is not None
+    maps_dir = run_state.write_dir / "maps"
+    maps_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(archive, maps_dir / "ExportMap.sdz")
+    reload_log = run_state.log_cursor()
+    reload_commands = run_state.command_cursor()
+    run_state.click_settled(*panel_point(left, TOOLBAR["new_project"]), delay=0.2)
+    run_state.click_settled(*dialog_point(run_state, DIALOG["new_project_name"]), delay=0.1)
+    run_state.type_text("FromExport")
+    run_state.click_settled(*dialog_point(run_state, DIALOG["new_project_map"]), delay=0.2)
+    run_state.click_settled(
+        *dialog_point(run_state, dropdown_option(DIALOG["new_project_map"], 1)), delay=0.2
+    )
+    run_state.click_settled(
+        *dialog_point(run_state, DIALOG["new_project_create_nosize"]), delay=0.1
+    )
+    run_state.wait_for_command("ReloadIntoProjectCommand", after=reload_commands)
+    run_state.wait_for_log("finished loading and is now ingame", after=reload_log)
+    reopened = run_state.screenshot("export-reopened")
+    painted_after = run_state.count_color(reopened, map_region, "#C87830", fuzz="18%")
+    if painted_after < 5_000:
+        raise AssertionError(
+            f"exported map lost its painted diffuse texture ({painted_after} warm pixels)"
+        )
+    if abs(painted_after - painted_before) > painted_before // 5:
+        raise AssertionError(
+            "exported diffuse texture moved within the map: "
+            f"{painted_before} warm pixels before export, {painted_after} after reopening"
+        )
+
 
 @scenario()
 def map_roundtrip(run_state: E2ERun) -> None: