Files
horizon-airdef/launcher/src/launch_page.rs
T
Ludovic Marie 9bc8e12ad1 launcher: GameMode, MangoHud and dedicated GPU switches on Linux
The Launch panel shows, per instance, a switch for each one this computer
has: GameMode when gamemoderun is on the PATH, MangoHud when mangohud is,
and the dedicated graphics card with two cards (DRI_PRIME, or NVIDIA's
render offload variables with its driver). They wrap the game like the
wrapper does, outermost first, and do nothing where the tool is gone.
CLI and MCP: instance launch --gamemode/--mangohud/--dedicated-gpu.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 04:28:42 +01:00

238 lines
8.3 KiB
Rust

//! Launch… on Home's Instance row: what runs around the selected instance's game
//! (`horizon_launcher::launch`): a command before it, a wrapper, and environment variables.
use super::servers_page::Field;
use super::*;
use horizon_launcher::launch;
pub(super) struct LaunchPanel {
/// The instance it is for: picking another closes it.
instance: String,
/// What Save did, or why not.
saved: Option<Result<String, String>>,
/// What this computer has for the Linux switches, looked at when the panel opens.
found: launch::Found,
}
/// A Linux switch: which one, its label, and what it does.
#[derive(Clone, Copy)]
enum Toggle {
GameMode,
MangoHud,
Gpu,
}
impl Launcher {
pub(super) fn toggle_launch(&mut self) {
if self.launch.take().is_some() {
return;
}
let Some(i) = self.selected_instance().cloned() else {
return;
};
*self.servers.text(Field::PreLaunch) = i.launch.pre_launch.clone();
*self.servers.text(Field::Wrapper) = i.launch.wrapper.clone();
*self.servers.text(Field::LaunchEnv) = launch::env_line(&i.launch.env);
self.launch = Some(LaunchPanel {
instance: i.id,
saved: None,
found: launch::Found::here(),
});
}
pub(super) fn save_launch(&mut self) {
let Some(id) = self.launch.as_ref().map(|p| p.instance.clone()) else {
return;
};
let pre = self.servers.value(Field::PreLaunch).trim().to_string();
let wrapper = self.servers.value(Field::Wrapper).trim().to_string();
let saved = launch::parse_env(self.servers.value(Field::LaunchEnv)).and_then(|env| {
instances::edit(&id, |m| {
m.launch = launch::Launch {
pre_launch: pre,
wrapper,
env,
..m.launch.clone()
}
})
});
let saved = saved.map(|i| {
let said = match i.launch.summary() {
Some(what) => format!("Saved: the next Play {what}."),
None => "Saved: nothing runs around the game.".to_string(),
};
self.reload_instances();
said
});
if let Some(p) = &mut self.launch {
p.saved = Some(saved);
}
}
/// Flips a Linux switch, saved at once.
fn flip(&mut self, toggle: Toggle) {
let Some(panel) = &mut self.launch else {
return;
};
let saved = instances::edit(&panel.instance, |m| {
let on = match toggle {
Toggle::GameMode => &mut m.launch.gamemode,
Toggle::MangoHud => &mut m.launch.mangohud,
Toggle::Gpu => &mut m.launch.dedicated_gpu,
};
*on = !*on;
});
panel.saved = Some(saved.map(|i| match i.launch.summary() {
Some(what) => format!("Saved: the next Play {what}."),
None => "Saved: nothing runs around the game.".to_string(),
}));
self.reload_instances();
}
/// The Linux switches this computer can use: GameMode and MangoHud when installed, the
/// dedicated GPU with two cards.
fn linux_switches(&self, cx: &mut Context<Self>) -> Option<Div> {
let t = self.theme;
let found = self.launch.as_ref()?.found;
let now = self.selected_instance()?.launch.clone();
let gpu_about = match found.nvidia {
true => "NVIDIA render offload: __NV_PRIME_RENDER_OFFLOAD and its Vulkan layer.",
false => "Mesa's DRI_PRIME=1, so Vulkan picks the other card.",
};
let mut list = div().flex().flex_col().gap(px(10.));
for (toggle, shown, on, label, about) in [
(
Toggle::GameMode,
found.gamemode,
now.gamemode,
"GameMode",
"Feral's gamemoderun: CPU and scheduler tuned while you play.",
),
(
Toggle::MangoHud,
found.mangohud,
now.mangohud,
"MangoHud",
"The frame time, CPU and GPU overlay.",
),
(
Toggle::Gpu,
found.two_gpus,
now.dedicated_gpu,
"Dedicated graphics card",
gpu_about,
),
] {
if !shown {
continue;
}
list = list.child(
div()
.id(SharedString::from(format!("launch-switch-{label}")))
.flex()
.items_center()
.gap(px(10.))
.cursor_pointer()
.child(switch(
SharedString::from(format!("launch-switch-{label}-s")),
on,
&t,
))
.child(text(theme::LABEL).text_color(t.ink_soft).child(label))
.child(text(theme::CAPTION).text_color(t.muted).child(about))
.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
this.flip(toggle);
cx.notify();
})),
);
}
found.any().then(|| {
div()
.flex()
.flex_col()
.gap(px(8.))
.child(caps("On this computer").text_color(t.muted))
.child(list)
})
}
/// The panel under the Instance row, while open for the selected instance.
pub(super) fn launch_panel(&mut self, cx: &mut Context<Self>) -> Option<Div> {
let t = self.theme;
let selected = self.selected_instance().map(|i| i.id.clone());
if self.launch.as_ref().map(|p| &p.instance) != selected.as_ref() {
self.launch = None;
}
let saved = self.launch.as_ref()?.saved.clone();
let row = |this: &mut Self,
cx: &mut Context<Self>,
label: &'static str,
field: Field,
placeholder: &'static str,
about: &'static str| {
div()
.flex()
.flex_col()
.gap(px(6.))
.child(caps(label).text_color(t.muted))
.child(this.field(field, placeholder, 520., cx))
.child(text(theme::CAPTION).text_color(t.muted).child(about))
};
let pre = row(
self,
cx,
"Before the game",
Field::PreLaunch,
"For example ./backup.sh",
"A shell command, run in the instance's folder. The game starts only if it succeeds.",
);
let wrapper = row(
self,
cx,
"Run the game through",
Field::Wrapper,
"For example nice -n 5",
"A program and its arguments; the game's command line goes after them.",
);
let env = row(
self,
cx,
"Environment variables",
Field::LaunchEnv,
"For example NAME=value OTHER=\"two words\"",
"For the game and both commands above.",
);
let save = button("launch-save", "Save", Kind::Secondary, &t).on_click(cx.listener(
|this, _: &ClickEvent, _, cx| {
this.save_launch();
cx.notify();
},
));
let result = saved.map(|s| match s {
Ok(said) => text(theme::CAPTION).text_color(t.muted).child(said),
Err(e) => text(theme::CAPTION).text_color(t.danger).child(e),
});
Some(
plate(&t)
.flex()
.flex_col()
.gap(px(14.))
.px(px(14.))
.py(px(12.))
.ml(px(40.))
.child(caps("When it starts").text_color(t.muted))
.child(pre)
.child(wrapper)
.child(env)
.children(self.linux_switches(cx))
.child(
div()
.flex()
.items_center()
.gap(px(12.))
.child(save)
.children(result),
),
)
}
}