Track the engine's new callin and coordinate contracts

The engine grew explicit parameters on several callins and moved mouse
callbacks onto Lua's coordinate contract. Follow both, and use the new
data rather than re-deriving it.

Callins: update takes a frame delta, draw_screen* take the view size,
and key_press/key_release carry modifiers, label, utf32 and the resolved
action list. Modifier flags now thread through the event dispatcher as
KeyMods, replacing the get_mod_key_state() polls that read live SDL state
a tick after the key they were matching. add_grass takes a grass value,
so the map writer stores each cell's real byte and the brush writes its
target level instead of a binary on/off.

Coordinates: mouse callbacks are now view-relative and bottom-origin, the
same space GetMouseState and the ray query already used. Traces therefore
stop flipping, while the panel and chonsole managers flip once on entry
for RmlUi's top-origin layout, and the control API converts explicitly
because its clients address the window like a screenshot.

E2E: park the cursor 40px above the window's bottom edge. EdgeMoveWidth
is a fraction of the view (~4px here), so parking at height-4 sat inside
the edge-scroll band and walked the camera south before most captures.

Author: gajop

native/src/sbc/chonsole/commands/executor.rs

@@ -77,9 +77,11 @@ impl CommandExecutor {
                 width,
                 height,
                 &export.output,
-                true,
-                true,
-                export.grayscale16,
+                spring_native::GfxSaveImageOptions {
+                    alpha: true,
+                    yflip: true,
+                    grayscale16bit: export.grayscale16,
+                },
                 0x8CE0,
             );
         });

native/src/sbc/chonsole/event_listener.rs

@@ -5,6 +5,7 @@ use spring_native::prelude::Error;
 use super::model::ChonsoleManager;
 use crate::sbc::command_system::model::Models;
 use crate::sbc::events::{Event, EventListener, EventListenerFactory, ListenerId};
+use crate::sbc::keys::KeyMods;
 
 inventory::submit! { EventListenerFactory { make: |_| Box::new(ChonsoleTextEvents) } }
 inventory::submit! { EventListenerFactory { make: |_| Box::new(ChonsoleEvents) } }
@@ -28,8 +29,9 @@ impl EventListener for ChonsoleTextEvents {
         key_code: i32,
         _scan_code: i32,
         _is_repeat: bool,
+        mods: KeyMods,
     ) -> Result<bool, Error> {
-        models.get::<ChonsoleManager>().text_key(key_code)
+        models.get::<ChonsoleManager>().text_key(key_code, mods)
     }
 }
 
@@ -68,17 +70,19 @@ impl EventListener for ChonsoleEvents {
         key_code: i32,
         scan_code: i32,
         is_repeat: bool,
+        mods: KeyMods,
     ) -> Result<bool, Error> {
         models
             .get::<ChonsoleManager>()
-            .key_press(key_code, scan_code, is_repeat)
+            .key_press(key_code, scan_code, is_repeat, mods)
     }
 
     fn key_release(
         &mut self,
         models: &mut Models,
         key_code: i32,
         scan_code: i32,
+        _mods: KeyMods,
     ) -> Result<bool, Error> {
         models
             .get::<ChonsoleManager>()

native/src/sbc/chonsole/integration/integration.rs

@@ -155,10 +155,12 @@ fn unitrules_lists_and_sets_selected_units(ctx: &mut TestCtx) -> Result<(), Stri
             },
             0,
             team,
-            false,
-            false,
-            -1,
-            -1,
+            spring_native::CreateUnitOptions {
+                build: false,
+                flatten_ground: false,
+                unit_id: -1,
+                builder_id: -1,
+            },
         )
         .map_err(|err| format!("create test unit: {err:?}"))?;
     interface

native/src/sbc/chonsole/model.rs

@@ -6,6 +6,7 @@ use super::commands::{CatalogRefresher, ChonsoleCore, CommandExecutor, CommandRe
 use super::framework::{ChonsoleResponse, ChonsoleSuggestion, HistoryStore};
 use super::ui::{ChonsoleController, UiKeyOutcome};
 use crate::sbc::command_system::model::{Model, ModelFactory};
+use crate::sbc::keys::KeyMods;
 use crate::sbc::port_flags::{self, PortImpl};
 
 inventory::submit! { ModelFactory { make: |iface| Box::new(ChonsoleManager::new(iface)) } }
@@ -128,14 +129,19 @@ impl ChonsoleManager {
         key_code: i32,
         scan_code: i32,
         is_repeat: bool,
+        mods: KeyMods,
     ) -> Result<bool, Error> {
         if !self.enabled {
             return Ok(false);
         }
-        match self
-            .ui
-            .key_press(&self.interface, &self.core, key_code, scan_code, is_repeat)?
-        {
+        match self.ui.key_press(
+            &self.interface,
+            &self.core,
+            key_code,
+            scan_code,
+            is_repeat,
+            mods,
+        )? {
             UiKeyOutcome::Unhandled => Ok(false),
             UiKeyOutcome::Handled => Ok(true),
             UiKeyOutcome::Execute(input) => {
@@ -146,11 +152,12 @@ impl ChonsoleManager {
         }
     }
 
-    pub fn text_key(&mut self, key_code: i32) -> Result<bool, Error> {
+    pub fn text_key(&mut self, key_code: i32, mods: KeyMods) -> Result<bool, Error> {
         if !self.enabled {
             return Ok(false);
         }
-        self.ui.text_key(&self.interface, &self.core, key_code)
+        self.ui
+            .text_key(&self.interface, &self.core, key_code, mods)
     }
 
     pub fn key_release(&mut self, key_code: i32, scan_code: i32) -> Result<bool, Error> {
@@ -179,20 +186,23 @@ impl ChonsoleManager {
             return Ok(false);
         }
         let _ = (dx, dy, button);
+        let y = self.rml_y(y);
         self.ui.mouse_move(&self.interface, x, y)
     }
 
     pub fn mouse_press(&mut self, x: i32, y: i32, button: i32) -> Result<bool, Error> {
         if !self.enabled {
             return Ok(false);
         }
+        let y = self.rml_y(y);
         self.ui.mouse_press(&self.interface, x, y, button)
     }
 
     pub fn mouse_release(&mut self, x: i32, y: i32, button: i32) -> Result<(), Error> {
         if !self.enabled {
             return Ok(());
         }
+        let y = self.rml_y(y);
         self.ui.mouse_release(&self.interface, x, y, button)
     }
 
@@ -203,6 +213,15 @@ impl ChonsoleManager {
         self.ui.mouse_wheel(&self.interface, up, value)
     }
 
+    /// Mouse callbacks report the engine's bottom-origin y; the view hit tests
+    /// against RmlUi's top-origin layout.
+    fn rml_y(&self, y: i32) -> i32 {
+        match self.interface.display().get_view_geometry() {
+            Ok(geometry) => geometry.viewSizeY - 1 - y,
+            Err(_) => y,
+        }
+    }
+
     fn persist_history_change(&self, previous_history: &[String]) {
         let Some(store) = &self.history_store else {
             return;

native/src/sbc/chonsole/ui/controller.rs

@@ -4,6 +4,7 @@ use super::events::{ChonsoleEvents, KeyOutcome};
 use super::view::ChonsoleView;
 use crate::sbc::chonsole::commands::ChonsoleCore;
 use crate::sbc::chonsole::framework::ChonsoleResponse;
+use crate::sbc::keys::KeyMods;
 
 #[derive(Default)]
 pub struct ChonsoleController {
@@ -54,16 +55,14 @@ impl ChonsoleController {
         key_code: i32,
         scan_code: i32,
         is_repeat: bool,
+        mods: KeyMods,
     ) -> Result<UiKeyOutcome, Error> {
+        let _ = (scan_code, is_repeat);
         Ok(
-            match self.events.key_press(
-                interface,
-                core,
-                &mut self.view,
-                key_code,
-                scan_code,
-                is_repeat,
-            )? {
+            match self
+                .events
+                .key_press(interface, core, &mut self.view, key_code, mods)?
+            {
                 KeyOutcome::Unhandled => UiKeyOutcome::Unhandled,
                 KeyOutcome::Handled => UiKeyOutcome::Handled,
                 KeyOutcome::Execute(input) => UiKeyOutcome::Execute(input),
@@ -75,9 +74,10 @@ impl ChonsoleController {
         interface: &NativeInterfaceRef,
         core: &ChonsoleCore,
         key_code: i32,
+        mods: KeyMods,
     ) -> Result<bool, Error> {
         self.events
-            .text_key(interface, core, &mut self.view, key_code)
+            .text_key(interface, core, &mut self.view, key_code, mods)
     }
     pub fn hide(&mut self, interface: &NativeInterfaceRef) -> Result<(), Error> {
         self.view.set_visible(interface, false)

native/src/sbc/chonsole/ui/events.rs

@@ -1,7 +1,7 @@
 use spring_native::prelude::{Error, NativeInterfaceRef};
 
 use crate::sbc::chonsole::commands::ChonsoleCore;
-use crate::sbc::keys::is_key;
+use crate::sbc::keys::{is_key, KeyMods};
 
 use super::view::ChonsoleView;
 
@@ -28,10 +28,8 @@ impl ChonsoleEvents {
         core: &ChonsoleCore,
         view: &mut ChonsoleView,
         key_code: i32,
-        scan_code: i32,
-        is_repeat: bool,
+        key_mods: KeyMods,
     ) -> Result<KeyOutcome, Error> {
-        let _ = (scan_code, is_repeat);
         self.modifiers.key_down(interface, key_code);
         if is_key(interface, key_code, "f10") {
             view.toggle(interface)?;
@@ -55,10 +53,10 @@ impl ChonsoleEvents {
         if is_key(interface, key_code, "enter") || is_key(interface, key_code, "numpad_enter") {
             return Ok(KeyOutcome::Execute(view.take_input()));
         }
-        if self.text_key(interface, core, view, key_code)? {
+        if self.text_key(interface, core, view, key_code, key_mods)? {
             return Ok(KeyOutcome::Handled);
         }
-        let mods = ModState::read(interface, self.modifiers);
+        let mods = ModState::read(key_mods, self.modifiers);
         if mods.ctrl && is_key(interface, key_code, "u") {
             self.reset_history_cursor();
             view.delete_to_start();
@@ -171,8 +169,9 @@ impl ChonsoleEvents {
         core: &ChonsoleCore,
         view: &mut ChonsoleView,
         key_code: i32,
+        key_mods: KeyMods,
     ) -> Result<bool, Error> {
-        if !view.visible() || !ModState::read(interface, self.modifiers).ctrl {
+        if !view.visible() || !ModState::read(key_mods, self.modifiers).ctrl {
             return Ok(false);
         }
         if is_key(interface, key_code, "a") {
@@ -272,14 +271,10 @@ struct ModState {
 }
 
 impl ModState {
-    fn read(interface: &NativeInterfaceRef, tracked: TrackedModifiers) -> Self {
-        let (_, ctrl, _, shift) = interface
-            .input()
-            .get_mod_key_state()
-            .unwrap_or((false, false, false, false));
+    fn read(mods: KeyMods, tracked: TrackedModifiers) -> Self {
         ModState {
-            shift: tracked.shift || shift,
-            ctrl: tracked.ctrl || ctrl,
+            shift: tracked.shift || mods.shift,
+            ctrl: tracked.ctrl || mods.ctrl,
         }
     }
 }

native/src/sbc/chonsole/ui/view_rml.rs

@@ -127,7 +127,7 @@ impl ChonsoleRml {
         rml.document_set_title(document, "Native Chonsole")?;
         rml.document_append_to_style_sheet(document, UI_STYLE)?;
         rml.element_set_inner_rml(document, UI_BODY)?;
-        rml.document_show(document, None, None)?;
+        rml.document_show(document, spring_native::RmlDocumentShowOptions::default())?;
         self.context = Some(context);
         self.document = Some(document);
         self.root = element_by_id(interface, document, "native-chonsole");
@@ -190,7 +190,7 @@ impl ChonsoleRml {
         };
         let rml = interface.rml_ui();
         if visible {
-            rml.document_show(document, None, None)?;
+            rml.document_show(document, spring_native::RmlDocumentShowOptions::default())?;
             if let Some(context) = self.context {
                 // Keep the engine/editor cursor stable over console controls.
                 let _ = rml.context_enable_mouse_cursor(context, false);

native/src/sbc/control/api/camera.rs

@@ -2,9 +2,11 @@
 
 use serde::Deserialize;
 use serde_json::json;
+
 use spring_native::prelude::NativeInterfaceRef;
 
 use crate::sbc::sbc::SBC;
+use crate::sbc::states::trace::{flip_screen_y, trace_editor_ground, trace_ground};
 
 use super::super::{ControlError, Handled, Reply};
 
@@ -162,7 +164,13 @@ pub(crate) fn set(sbc: &mut SBC, params: Set) -> Handled {
     if let Some([x, y, z]) = params.target {
         let target = spring_native::prelude::sys::Float3 { x, y, z };
         camera
-            .set_camera_target(target, params.transition)
+            .set_camera_target(
+                target,
+                spring_native::SetCameraTargetOptions {
+                    transition_time: Some(params.transition),
+                    ..Default::default()
+                },
+            )
             .map_err(|err| ControlError::failed(format!("set_camera_target: {err:?}")))?;
     }
     get(sbc)
@@ -181,7 +189,8 @@ pub(crate) fn zoom(sbc: &mut SBC, params: Zoom) -> Handled {
                 "camera.zoom screen coordinates must be finite",
             ));
         }
-        trace_ground(interface, screen)?
+        trace_ground(interface, screen[0], engine_screen_y(interface, screen[1]))
+            .map(|hit| [hit.x, hit.y, hit.z])
     } else {
         None
     };
@@ -211,7 +220,10 @@ pub(crate) fn zoom(sbc: &mut SBC, params: Zoom) -> Handled {
         // point beneath the cursor. Re-trace after scaling and apply the
         // horizontal ground delta in the controller, where the engine owns the
         // camera projection and terrain height.
-        if let Some(current) = trace_ground(interface, screen)? {
+        if let Some(current) =
+            trace_ground(interface, screen[0], engine_screen_y(interface, screen[1]))
+                .map(|hit| [hit.x, hit.y, hit.z])
+        {
             let mut state = camera
                 .get_camera_state(false)
                 .map_err(|err| ControlError::failed(format!("get_camera_state: {err:?}")))?;
@@ -234,25 +246,21 @@ pub(crate) fn trace(sbc: &mut SBC, params: Trace) -> Handled {
             "camera.trace screen coordinates must be finite",
         ));
     }
-    let (hit_type, hit_id, position) = sbc
-        .interface()
-        .camera()
-        .trace_screen_ray(x, y, true, false, false, true, 0.0)
+    let interface = sbc.interface();
+    let trace = trace_editor_ground(interface, x, engine_screen_y(interface, y))
         .map_err(|err| ControlError::failed(format!("trace_screen_ray: {err:?}")))?;
     Ok(Reply::now(json!({
-        "hit_type": hit_type,
-        "hit_id": hit_id,
-        "position": [position.x, position.y, position.z],
+        "hit_type": trace.hit_type,
+        "hit_id": trace.hit_id,
+        "position": [trace.position.x, trace.position.y, trace.position.z],
     })))
 }
 
-fn trace_ground(
-    interface: &NativeInterfaceRef,
-    screen: [f32; 2],
-) -> Result<Option<[f32; 3]>, ControlError> {
-    let (hit_type, _, position) = interface
-        .camera()
-        .trace_screen_ray(screen[0], screen[1], true, false, false, true, 0.0)
-        .map_err(|err| ControlError::failed(format!("trace_screen_ray: {err:?}")))?;
-    Ok((hit_type == 3).then_some([position.x, position.y, position.z]))
+/// Control clients address the window the way a screenshot does: top-origin.
+/// The engine's screen space is bottom-origin, so convert on the way in.
+fn engine_screen_y(interface: &NativeInterfaceRef, y: f32) -> f32 {
+    match interface.display().get_view_geometry() {
+        Ok(geometry) => flip_screen_y(geometry.viewSizeY as f32, y),
+        Err(_) => y,
+    }
 }