Xbox Cloud Gaming app for PS5 Homebrew
C
// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2026 RafaelNGP
// The streaming screen on the main thread; see stream_screen.h.
#include "app/stream_screen.h"
#include "app/app_state.h"
#include "app/autoplay.h"
#include "app/shell.h"
#include "app/stream_player.h"
#include "app/web_server.h"
#include "display/display.h"
#include "input/input_ext.h"
#include "input/kbm.h"
#include "input/keyboard_nav.h"
#include "input/pad_usb.h"
#include "media/audio_out.h"
#include "platform/platform.h"
#include "platform/toasts.h"
#include "ui/strings.h"
#include "ui/toast_view.h"
#include "util/log.h"
#include <algorithm>
#include <cmath>
namespace xc::app {
namespace {
// How much CAS each sharpness level mixes in (display::setSharpness).
constexpr int kSharpAmount[] = {0, 96, 176, 256};
// The game menu's upscaling: 0 FSR, 1 Anime4K, 2 FSR + clean-up, 3 Anime4K +
// clean-up (Anime4K Restore before the upscale).
void applyUpscaler(int mode) {
display::setUpscaler(mode & 1);
display::setRestore(mode >= 2);
}
// The console keyboard answering a game's text field (main thread): the
// request it answers, and the stream that asked.
std::string g_keyboardFor;
const app::StreamPlayer* g_keyboardPlayer = nullptr;
platform::KeyboardKind keyboardKind(int inputScope) {
switch (inputScope) {
case 1: return platform::KeyboardKind::Url;
case 5: return platform::KeyboardKind::Email;
case 29:
case 32: return platform::KeyboardKind::Number;
case 31: return platform::KeyboardKind::Password;
default: return platform::KeyboardKind::Text;
}
}
// Opens the keyboard for the game's next text request and sends back what
// was typed. `player` null: the stream is gone, a keyboard still up is
// closed by the player and its text dropped.
void updateTextInput(app::StreamPlayer* player) {
if (!g_keyboardFor.empty()) {
std::string text;
platform::KeyboardStatus st = platform::pollSystemKeyboard(text);
if (st == platform::KeyboardStatus::Open) return;
if (player && player == g_keyboardPlayer)
player->answerTextInput(g_keyboardFor, st == platform::KeyboardStatus::Accepted, text);
g_keyboardFor.clear();
g_keyboardPlayer = nullptr;
return;
}
stream::TextInputRequest req;
if (!player || !player->takeTextInput(req)) return;
std::string title = req.title.empty() ? req.description : req.title;
size_t max = req.maxLength > 0 ? static_cast<size_t>(req.maxLength) : 256;
if (platform::openSystemKeyboard(title, req.defaultText, max, keyboardKind(req.inputScope))) {
g_keyboardFor = req.id;
g_keyboardPlayer = player;
} else {
player->answerTextInput(req.id, false, std::string());
}
}
} // namespace
void StreamScreen::setPads(const ui::PadSlots& slots) {
menu_.setPads(slots);
if (menu_.isOpen()) overlaySeq_ = 0;
}
void StreamScreen::setCaps(const ui::UiCaps& caps) {
if (caps == menu_.capabilities()) return;
menu_.setCapabilities(caps);
if (menu_.isOpen()) overlaySeq_ = 0;
}
void StreamScreen::setMouseCaptured_(bool captured) {
if (captured == mouseCaptured_) return;
mouseCaptured_ = captured;
input::kbmSetCaptured(captured);
}
void StreamScreen::applyDeband_() { display::setDeband(deband_ == 3 ? autoDeband_.level() : deband_); }
void StreamScreen::syncFromSettings() {
if (!wasStreaming_) return;
ui::GameTile tile;
{
std::lock_guard<std::mutex> argLock(g_argMutex);
tile = g_playTile;
}
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
bool hasCustom = false;
GameProfile prof = g_settings.profileForGame(tile.productId, tile.titleId, &hasCustom);
hasCustomProfile_ = hasCustom;
touchpadMouse_ = prof.touchpadMouse;
streamResolution_ = prof.resolution;
showStats_ = g_settings.streamStats;
menu_.setStatsOn(showStats_);
menu_.setStatsMask(g_settings.statsMask);
sharpness_ = g_autoplay.sharpness >= 0 ? g_autoplay.sharpness : prof.sharpness;
display::setSharpness(kSharpAmount[std::clamp(sharpness_, 0, 3)]);
deband_ = g_autoplay.deband >= 0 ? g_autoplay.deband : prof.deband;
applyDeband_();
upscaler_ = g_autoplay.upscaler >= 0 ? g_autoplay.upscaler : prof.upscaler;
if (g_autoplay.restore) upscaler_ = (upscaler_ & 1) | 2;
applyUpscaler(upscaler_);
triggerStrength_ = prof.triggerStrength;
triggerProfile_ = prof.triggerProfile;
deadzone_ = prof.deadzoneLeft;
circleConfirms_ = prof.circleConfirms;
keyMap_ = prof.keyMap;
padMap_ = prof.padMap;
touchpadShortcuts_ = prof.touchpadShortcuts;
gyroMode_ = prof.gyroMode;
gyroLevel_ = prof.gyroLevel;
input::setGyro(gyroMode_, gyroLevel_);
input::setDeadzone(prof.deadzoneLeft / 100.0f, prof.deadzoneRight / 100.0f);
input::setTriggerFeel(prof.triggerStrength, prof.triggerHz, prof.triggerResistance, prof.triggerPulses, triggerProfile_);
input::setCircleConfirms(prof.circleConfirms);
if (g_ui) g_ui->setCircleConfirms(prof.circleConfirms);
media::audioSetRoute(static_cast<media::AudioRoute>(g_settings.audioRoute));
media::audioSetVoiceRouting(g_settings.voiceRouting);
media::setPadSpeakerVolume(g_settings.padSpeakerVolume);
if (g_player) {
g_player->setMicGain(g_settings.micGainFactor());
}
menu_.setProfileValues(streamResolution_, sharpness_, deband_, upscaler_,
triggerStrength_, deadzone_, circleConfirms_, hasCustomProfile_);
menu_.setGyro(gyroMode_, gyroLevel_);
menu_.setTouchpadShortcuts(touchpadShortcuts_);
menu_.setPadSpeakerVolume(g_settings.padSpeakerVolume);
overlaySeq_ = 0;
}
void StreamScreen::executeTouchpadAction_(input::TouchpadAction act, const char* triggerName) {
switch (act) {
case input::TouchpadAction::None:
break;
case input::TouchpadAction::GameMenu:
swipeMenu_ = true;
XC_LOGI("touchpad %s: game menu", triggerName);
break;
case input::TouchpadAction::XboxButton:
if (!menu_.isOpen()) {
g_xboxButtonUntil = platform::nowMs() + 250;
XC_LOGI("touchpad %s: Xbox button", triggerName);
}
break;
case input::TouchpadAction::ToggleStats:
showStats_ = !showStats_;
menu_.setStatsOn(showStats_);
{
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
g_settings.streamStats = showStats_;
g_settings.save(settingsPath());
refreshSettingsUiLocked();
}
overlaySeq_ = 0;
platform::notify(showStats_ ? "Telemetria ativada" : "Telemetria desativada",
showStats_ ? "stats on" : "stats off");
XC_LOGI("touchpad %s: toggle stats -> %d", triggerName, showStats_ ? 1 : 0);
break;
case input::TouchpadAction::ToggleMicMute:
if (g_player) {
bool muted = !g_player->micMuted();
g_player->setMicMuted(muted);
menu_.setMicMuted(muted || g_player->isMicHardwareMuted());
overlaySeq_ = 0;
platform::notify(muted ? "Microfone silenciado" : "Microfone ativado",
muted ? "mic muted" : "mic unmuted");
XC_LOGI("touchpad %s: toggle mic mute -> %d", triggerName, muted ? 1 : 0);
}
break;
case input::TouchpadAction::CycleGyro:
gyroMode_ = (gyroMode_ + 1) % 3;
input::setGyro(gyroMode_, gyroLevel_);
menu_.setGyro(gyroMode_, gyroLevel_);
{
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
if (hasCustomProfile_) g_settings.perGame[gameKey_].gyroMode = gyroMode_;
else g_settings.gyroMode = gyroMode_;
g_settings.save(settingsPath());
refreshSettingsUiLocked();
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
}
overlaySeq_ = 0;
{
const char* gyroName = gyroMode_ == 1 ? ui::tr(ui::Str::GyroAlways)
: gyroMode_ == 2 ? ui::tr(ui::Str::GyroAiming)
: ui::tr(ui::Str::Off);
platform::notify(std::string(ui::tr(ui::Str::Gyro)) + ": " + gyroName, "cycle gyro");
}
XC_LOGI("touchpad %s: cycle gyro -> %d", triggerName, gyroMode_);
break;
case input::TouchpadAction::CycleTriggerProfile:
triggerProfile_ = (triggerProfile_ + 1) % 3;
{
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
input::setTriggerFeel(triggerStrength_, g_settings.triggerHz, g_settings.triggerResistance, g_settings.triggerPulses, triggerProfile_);
if (hasCustomProfile_) g_settings.perGame[gameKey_].triggerProfile = triggerProfile_;
else g_settings.triggerProfile = triggerProfile_;
g_settings.save(settingsPath());
refreshSettingsUiLocked();
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
}
overlaySeq_ = 0;
{
const char* profName = triggerProfile_ == 1 ? ui::tr(ui::Str::TriggerProfileShooter)
: triggerProfile_ == 2 ? ui::tr(ui::Str::TriggerProfileRacing)
: ui::tr(ui::Str::TriggerProfileStd);
platform::notify(std::string(ui::tr(ui::Str::TriggerProfile)) + ": " + profName, "cycle trigger profile");
}
XC_LOGI("touchpad %s: cycle trigger profile -> %d", triggerName, triggerProfile_);
break;
default:
if (!menu_.isOpen() && input::isTouchpadButtonAction(act)) {
shortcutPulseAction_ = act;
shortcutPulseUntilMs_ = platform::nowMs() + 200;
XC_LOGI("touchpad %s: button %s", triggerName, ui::touchpadActionLabel(static_cast<int>(act)).c_str());
}
break;
}
}
void StreamScreen::update(const input::ControllerState& pad, ui::NavInput nav, bool menuCombo) {
std::lock_guard<std::mutex> lock(g_playerMutex);
if (g_player != overlayPlayer_ || (g_player && g_player->reconnects() != playerReconnects_)) {
// A new stream, or a new session after a reconnection: the
// other controllers are announced again.
for (bool& a : padAttached_) a = false;
for (bool& a : padUsbOnly_) a = false;
menuUsbOwner_ = pendingUsbMenu_ = -1;
playerReconnects_ = g_player ? g_player->reconnects() : 0;
}
if (g_player != overlayPlayer_) { // a new stream
overlayPlayer_ = g_player;
wasStreaming_ = true;
menu_.close();
ui::GameTile tile;
{
std::lock_guard<std::mutex> argLock(g_argMutex);
tile = g_playTile;
}
gameKey_ = gameProfileKey(tile.productId, tile.titleId);
mouseKeyboard_ = tile.mouseKeyboard && !tile.homeConsole;
touchMouse_ = {};
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
bool hasCustom = false;
GameProfile prof = g_settings.profileForGame(tile.productId, tile.titleId, &hasCustom);
hasCustomProfile_ = hasCustom;
touchpadMouse_ = prof.touchpadMouse;
streamResolution_ = prof.resolution;
showStats_ = g_settings.streamStats;
menu_.setStatsMask(g_settings.statsMask);
sharpness_ = g_autoplay.sharpness >= 0 ? g_autoplay.sharpness : prof.sharpness;
display::setSharpness(kSharpAmount[std::clamp(sharpness_, 0, 3)]);
deband_ = g_autoplay.deband >= 0 ? g_autoplay.deband : prof.deband;
autoDeband_.reset();
applyDeband_();
upscaler_ = g_autoplay.upscaler >= 0 ? g_autoplay.upscaler : prof.upscaler;
if (g_autoplay.restore) upscaler_ = (upscaler_ & 1) | 2;
applyUpscaler(upscaler_);
// Apply controller profile settings
triggerStrength_ = prof.triggerStrength;
triggerProfile_ = prof.triggerProfile;
deadzone_ = prof.deadzoneLeft;
circleConfirms_ = prof.circleConfirms;
keyMap_ = prof.keyMap;
padMap_ = prof.padMap;
touchpadShortcuts_ = prof.touchpadShortcuts;
menu_.setTouchpadShortcuts(touchpadShortcuts_);
gyroMode_ = prof.gyroMode;
gyroLevel_ = prof.gyroLevel;
input::setGyro(gyroMode_, gyroLevel_);
input::setDeadzone(prof.deadzoneLeft / 100.0f, prof.deadzoneRight / 100.0f);
input::setTriggerFeel(prof.triggerStrength, prof.triggerHz, prof.triggerResistance, prof.triggerPulses, triggerProfile_);
input::setCircleConfirms(prof.circleConfirms);
if (g_ui) g_ui->setCircleConfirms(prof.circleConfirms);
// 120 Hz (VRR) for this game's stream: active when enabled in profile,
// or defaulted on when the display supports switching refresh (menus stay at 60 Hz).
bool want120 = (prof.highRefresh || (!hasCustom && display::canSwitchRefresh())) && !g_autoplay.hz60;
highRefresh_ = want120 && display::setHighRefresh(true);
media::audioSetRoute(static_cast<media::AudioRoute>(g_settings.audioRoute));
media::audioSetVoiceRouting(g_settings.voiceRouting);
if (g_player) {
g_player->setHighRefreshOutput(highRefresh_);
g_player->setMicGain(g_settings.micGainFactor());
}
overlaySeq_ = 0;
}
if (g_player) {
updateTextInput(g_player);
if (pad.touching) touchLastX_ = pad.touchX;
// L3 + R3 simultaneous press toggles HUD statistics overlay
bool l3r3 = pad.btnL3 && pad.btnR3;
if (l3r3 && !prevL3R3_ && !menu_.isOpen()) {
showStats_ = !showStats_;
menu_.setStatsOn(showStats_);
{
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
g_settings.streamStats = showStats_;
g_settings.save(settingsPath());
refreshSettingsUiLocked();
}
overlaySeq_ = 0;
platform::notify(showStats_ ? "Telemetria ativada" : "Telemetria desativada",
showStats_ ? "stats on" : "stats off");
}
prevL3R3_ = l3r3;
// OPTIONS + TOUCHPAD opens the menu (and closes it again); so does a
// USB controller's Xbox / Home button, for that controller.
const int usbMenu = pendingUsbMenu_;
pendingUsbMenu_ = -1;
if (menu_.isOpen() && menuUsbOwner_ >= 0 && input::usbPadPlayer(menuUsbOwner_) < 0) {
menu_.close(); // its controller went away
overlaySeq_ = 0;
}
bool wasOpen = menu_.isOpen();
if (!wasOpen && (menuCombo || swipeMenu_ || usbMenu >= 0) && g_keyboardFor.empty()) {
menuUsbOwner_ = menuCombo || swipeMenu_ ? -1 : usbMenu;
menu_.setUsbOwner(menuUsbOwner_ >= 0 ? input::usbPadPlayer(menuUsbOwner_) : -1);
if (menuUsbOwner_ >= 0)
XC_LOGI("menu_: opened by usb pad %d (player %d)", menuUsbOwner_, menu_.usbOwnerPlayer() + 1);
swipeMenu_ = false;
menu_.setCircleConfirms(circleConfirms_);
bool allow1440;
{
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
allow1440 = allow1440Locked();
}
float micLvl = g_player ? g_player->micLevel() : 0.0f;
bool micMuted = g_player ? (g_player->micMuted() || g_player->isMicHardwareMuted()) : false;
menu_.setDebandInUse(autoDeband_.level());
menu_.setGyro(gyroMode_, gyroLevel_);
menu_.setTouchpadShortcuts(touchpadShortcuts_);
menu_.setStatsMask(g_settings.statsMask);
int padVol = 100;
{
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
padVol = g_settings.padSpeakerVolume;
}
menu_.open(streamResolution_, showStats_, sharpness_, deband_, upscaler_, g_playingHome, allow1440,
hasCustomProfile_, triggerStrength_, deadzone_, circleConfirms_, micLvl, micMuted, padVol);
overlaySeq_ = 0;
} else if (wasOpen && (menuCombo || swipeMenu_ || (usbMenu >= 0 && usbMenu == menuUsbOwner_))) {
// The same gesture or key closes it again.
swipeMenu_ = false;
menu_.close();
overlaySeq_ = 0;
g_player->requestKeyframe();
} else if (wasOpen) {
switch (menu_.handle(nav)) {
case ui::MenuAction::Leave: g_cancel = true; break;
case ui::MenuAction::XboxButton: {
// A short press, once the menu is gone: the Xbox guide opens,
// for the player whose controller opened the menu.
const int player = menuUsbOwner_ >= 0 ? std::max(input::usbPadPlayer(menuUsbOwner_), 0) : 0;
if (player > 0) xboxUntil_[player] = platform::nowMs() + 250;
else g_xboxButtonUntil = platform::nowMs() + 250;
g_player->requestKeyframe();
XC_LOGI("menu_: Xbox button (player %d)", player + 1);
break;
}
case ui::MenuAction::Player:
input::setUsbPadPlayer(menuUsbOwner_, menu_.usbOwnerPlayer());
break;
case ui::MenuAction::PadSpeakerVolume: {
int vol = menu_.padSpeakerVolume();
media::setPadSpeakerVolume(vol);
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
g_settings.padSpeakerVolume = vol;
g_settings.save(settingsPath());
refreshSettingsUiLocked();
break;
}
case ui::MenuAction::Close: g_player->requestKeyframe(); break; // a clean picture back in the game
case ui::MenuAction::Resolution:
streamResolution_ = menu_.resolution();
g_tierPicked = true;
// The user's own Xbox: 1080p is its top tier ("1440").
g_player->requestResolution(streamResolution_ == 1 ? "720HQ"
: streamResolution_ == 2 || g_playingHome ? "1440"
: "1080HQ");
{
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
if (hasCustomProfile_) {
g_settings.perGame[gameKey_].resolution = streamResolution_;
g_settings.save(settingsPath());
}
++g_settingsVersion;
}
break;
case ui::MenuAction::ProfileToggle: {
hasCustomProfile_ = menu_.hasCustomProfile();
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
if (hasCustomProfile_) {
GameProfile p;
p.sharpness = sharpness_;
p.deband = deband_;
p.upscaler = upscaler_;
p.resolution = streamResolution_;
p.deadzoneLeft = deadzone_;
p.deadzoneRight = deadzone_;
p.triggerStrength = triggerStrength_;
p.triggerHz = g_settings.triggerHz;
p.triggerResistance = g_settings.triggerResistance;
p.triggerPulses = g_settings.triggerPulses;
p.triggerProfile = triggerProfile_;
p.circleConfirms = circleConfirms_;
auto had = g_settings.perGame.find(gameKey_); // not set from this menu: kept
p.highRefresh = had != g_settings.perGame.end() ? had->second.highRefresh : g_settings.highRefresh;
p.keyMap = had != g_settings.perGame.end() ? had->second.keyMap : g_settings.keyMap;
p.padMap = had != g_settings.perGame.end() ? had->second.padMap : g_settings.padMap;
p.locale = had != g_settings.perGame.end() ? had->second.locale : std::string();
p.syncTrophies = had != g_settings.perGame.end() ? had->second.syncTrophies : true;
p.xboxTitleId = had != g_settings.perGame.end() ? had->second.xboxTitleId : std::string();
p.gameName = had != g_settings.perGame.end() ? had->second.gameName : std::string();
p.touchpadShortcuts = touchpadShortcuts_;
p.touchpadMouse = touchpadMouse_;
p.gyroMode = gyroMode_;
p.gyroLevel = gyroLevel_;
g_settings.perGame[gameKey_] = p;
} else {
g_settings.perGame.erase(gameKey_);
auto def = g_settings.defaultProfile();
sharpness_ = def.sharpness;
deband_ = def.deband;
upscaler_ = def.upscaler;
streamResolution_ = def.resolution;
deadzone_ = def.deadzoneLeft;
triggerStrength_ = def.triggerStrength;
triggerProfile_ = def.triggerProfile;
keyMap_ = def.keyMap;
padMap_ = def.padMap;
touchpadShortcuts_ = def.touchpadShortcuts;
touchpadMouse_ = def.touchpadMouse;
circleConfirms_ = def.circleConfirms;
gyroMode_ = def.gyroMode;
gyroLevel_ = def.gyroLevel;
input::setGyro(gyroMode_, gyroLevel_);
menu_.setGyro(gyroMode_, gyroLevel_);
menu_.setTouchpadShortcuts(touchpadShortcuts_);
display::setSharpness(kSharpAmount[sharpness_]);
applyDeband_();
applyUpscaler(upscaler_);
input::setDeadzone(deadzone_ / 100.0f, deadzone_ / 100.0f);
input::setTriggerFeel(triggerStrength_, g_settings.triggerHz, g_settings.triggerResistance, g_settings.triggerPulses, triggerProfile_);
input::setCircleConfirms(circleConfirms_);
menu_.setProfileValues(streamResolution_, sharpness_, deband_, upscaler_,
triggerStrength_, deadzone_, circleConfirms_, false);
}
g_settings.save(settingsPath());
refreshSettingsUiLocked();
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
break;
}
case ui::MenuAction::Sharpness: {
sharpness_ = menu_.sharpness();
display::setSharpness(kSharpAmount[sharpness_]);
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
if (hasCustomProfile_) g_settings.perGame[gameKey_].sharpness = sharpness_;
else g_settings.sharpness = sharpness_;
g_settings.save(settingsPath());
refreshSettingsUiLocked(); // else leaving Settings later would put the old value back
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
break;
}
case ui::MenuAction::Upscaler: {
upscaler_ = menu_.upscaler();
applyUpscaler(upscaler_);
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
if (hasCustomProfile_) g_settings.perGame[gameKey_].upscaler = upscaler_;
else g_settings.upscaler = upscaler_;
g_settings.save(settingsPath());
refreshSettingsUiLocked();
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
break;
}
case ui::MenuAction::Deband: {
deband_ = menu_.deband();
applyDeband_();
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
if (hasCustomProfile_) g_settings.perGame[gameKey_].deband = deband_;
else g_settings.deband = deband_;
g_settings.save(settingsPath());
refreshSettingsUiLocked();
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
break;
}
case ui::MenuAction::Triggers: {
triggerStrength_ = menu_.triggerStrength();
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
input::setTriggerFeel(triggerStrength_, g_settings.triggerHz, g_settings.triggerResistance, g_settings.triggerPulses);
if (hasCustomProfile_) g_settings.perGame[gameKey_].triggerStrength = triggerStrength_;
else g_settings.triggerStrength = triggerStrength_;
g_settings.save(settingsPath());
refreshSettingsUiLocked();
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
break;
}
case ui::MenuAction::Deadzone: {
deadzone_ = menu_.deadzone();
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
input::setDeadzone(deadzone_ / 100.0f, deadzone_ / 100.0f);
if (hasCustomProfile_) {
g_settings.perGame[gameKey_].deadzoneLeft = deadzone_;
g_settings.perGame[gameKey_].deadzoneRight = deadzone_;
} else {
g_settings.deadzoneLeft = deadzone_;
g_settings.deadzoneRight = deadzone_;
}
g_settings.save(settingsPath());
refreshSettingsUiLocked();
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
break;
}
case ui::MenuAction::Gyro: {
gyroMode_ = menu_.gyroMode();
gyroLevel_ = menu_.gyroLevel();
input::setGyro(gyroMode_, gyroLevel_);
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
if (hasCustomProfile_) {
g_settings.perGame[gameKey_].gyroMode = gyroMode_;
g_settings.perGame[gameKey_].gyroLevel = gyroLevel_;
} else {
g_settings.gyroMode = gyroMode_;
g_settings.gyroLevel = gyroLevel_;
}
g_settings.save(settingsPath());
refreshSettingsUiLocked(); // the gyro's defaults too
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
break;
}
case ui::MenuAction::ConfirmButton: {
circleConfirms_ = menu_.circleConfirms();
input::setCircleConfirms(circleConfirms_);
if (g_ui) g_ui->setCircleConfirms(circleConfirms_);
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
if (hasCustomProfile_) g_settings.perGame[gameKey_].circleConfirms = circleConfirms_;
else g_settings.circleConfirms = circleConfirms_;
g_settings.save(settingsPath());
refreshSettingsUiLocked();
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
break;
}
case ui::MenuAction::Stats: {
showStats_ = menu_.statsOn();
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
g_settings.streamStats = showStats_;
g_settings.statsMask = menu_.statsMask();
g_settings.save(settingsPath());
refreshSettingsUiLocked();
break;
}
case ui::MenuAction::TouchpadShortcuts: {
touchpadShortcuts_ = menu_.touchpadShortcuts();
std::lock_guard<std::mutex> settingsLock(g_settingsMutex);
if (hasCustomProfile_) g_settings.perGame[gameKey_].touchpadShortcuts = touchpadShortcuts_;
else g_settings.touchpadShortcuts = touchpadShortcuts_;
g_settings.save(settingsPath());
refreshSettingsUiLocked();
if (g_ui) g_ui->setPerGameSettings(g_settings.perGame);
break;
}
default: break;
}
overlaySeq_ = 0;
}
// Closed: the USB controllers wait for their buttons to be let go
// (the one that closed it would press them in the game).
if (wasOpen && !menu_.isOpen()) {
input::usbPadsWaitRelease();
menuUsbOwner_ = -1;
}
input::KbmInput touchKbm;
bool touchDrag = false;
if (mouseKeyboard_ && touchpadMouse_ && !menu_.isOpen() && g_keyboardFor.empty() && !menuCombo) {
touchDrag = input::touchpadAsMouse(pad, platform::nowMs(), touchMouse_, touchKbm);
} else {
if (touchMouse_.prevButtons != 0) touchKbm.moved = true; // let go of any held touchpad mouse button
touchMouse_ = {};
}
// Touchpad click left / click right action resolution
input::TouchpadAction clickAct = (touchLastX_ >= 0.5f) ? touchpadShortcuts_.clickRight : touchpadShortcuts_.clickLeft;
const char* clickSide = (touchLastX_ >= 0.5f) ? "click right" : "click left";
if (pad.btnTouchpad && !prevTouchpad_ && !menuCombo && !touchDrag && g_keyboardFor.empty()) {
if (menu_.isOpen()) {
if (clickAct == input::TouchpadAction::GameMenu) {
swipeMenu_ = true;
XC_LOGI("touchpad %s: game menu", clickSide);
}
} else if (!input::isTouchpadButtonAction(clickAct) && clickAct != input::TouchpadAction::None) {
executeTouchpadAction_(clickAct, clickSide);
}
}
prevTouchpad_ = pad.btnTouchpad;
// The game gets the buttons through this game's map (Settings >
// Controller buttons); everything above (the menu's combo, the
// menu itself) read them as they are.
input::ControllerState padIn = pad;
if (touchDrag || clickAct != input::TouchpadAction::View) {
padIn.btnTouchpad = false; // held as a mouse button or mapped to a custom touchpad click action
}
input::ControllerState sent = input::applyPadMap(padIn, padMap_);
if (g_syntheticA) sent.btnA = true;
if (float x = g_syntheticRightX; x != 0.0f) sent.rightStickX = x;
if (float y = g_syntheticLeftY; y != 0.0f) sent.leftStickY = y;
// While another window has the focus on the cloud console (a
// publisher's page such as NetEase's terms in Marvel Rivals,
// which then shows its own pad-driven cursor), touch input is
// on, as the web client has it on touch screens.
bool unfocused = !g_player->titleFocused();
if (unfocused != touchEnabled_) {
touchEnabled_ = unfocused;
g_player->setTouchEnabled(unfocused);
}
// The menu and the keyboard have the pad while they are up,
// and the buttons that closed them until they are let go.
bool held = pad.dpadUp || pad.dpadDown || pad.dpadLeft || pad.dpadRight || pad.btnA || pad.btnB ||
pad.btnX || pad.btnY || pad.btnOptions || pad.btnTouchpad;
// A menu a USB controller opened is that controller's: player 1 plays on.
if ((menu_.isOpen() && menuUsbOwner_ < 0) || !g_keyboardFor.empty()) padReleased_ = false;
else if (!held) padReleased_ = true;
if (!padReleased_ || menuCombo) sent = input::ControllerState{};
else if (!menu_.isOpen() && !touchDrag) {
if (pad.btnTouchpad && input::isTouchpadButtonAction(clickAct) && clickAct != input::TouchpadAction::View) {
input::applyTouchpadButtonAction(sent, clickAct);
}
if (platform::nowMs() < shortcutPulseUntilMs_) {
input::applyTouchpadButtonAction(sent, shortcutPulseAction_);
}
}
// Touchpad swipe gestures (once per swipe; the games never see the
// touchpad's touches). In MKB games the touchpad moves the mouse while the menu is closed.
bool swipeOn = (!mouseKeyboard_ || !touchpadMouse_) || menu_.isOpen();
if (swipeOn && pad.touching && !pad.btnTouchpad && g_keyboardFor.empty()) {
if (!swipe_.active) swipe_ = {true, false, pad.touchX, pad.touchY};
float dx = pad.touchX - swipe_.x, dy = swipe_.y - pad.touchY; // dy > 0: up
bool right = dx > 0.30f && std::abs(dy) < 0.30f, up = dy > 0.40f && std::abs(dx) < 0.30f;
bool left = dx < -0.30f && std::abs(dy) < 0.30f, down = dy < -0.40f && std::abs(dx) < 0.30f;
if (!swipe_.fired && (up || down || left || right)) {
input::TouchpadAction act = up ? touchpadShortcuts_.swipeUp
: down ? touchpadShortcuts_.swipeDown
: left ? touchpadShortcuts_.swipeLeft
: touchpadShortcuts_.swipeRight;
const char* dirName = up ? "swipe up" : down ? "swipe down" : left ? "swipe left" : "swipe right";
if (menu_.isOpen()) {
if (act == input::TouchpadAction::GameMenu) {
swipe_.fired = true;
swipeMenu_ = true;
XC_LOGI("touchpad %s: game menu", dirName);
}
} else if (act != input::TouchpadAction::None) {
swipe_.fired = true;
executeTouchpadAction_(act, dirName);
if (platform::nowMs() < shortcutPulseUntilMs_ && padReleased_ && !menuCombo) {
input::applyTouchpadButtonAction(sent, shortcutPulseAction_);
}
}
}
} else {
swipe_.active = false;
if (!pad.touching) swipe_.fired = false;
else if (pad.btnTouchpad) swipe_.fired = true;
}
if (!menu_.isOpen()) {
input::ControllerState vpad0;
bool vconn0 = false;
if (virtualGamepadState(0, vpad0, vconn0) && vconn0) {
input::mergePads(sent, vpad0);
if (vpad0.btnNexus) {
sent.btnNexus = true;
g_xboxButtonUntil = platform::nowMs() + 250;
}
}
}
if (platform::nowMs() < g_xboxButtonUntil) sent.btnNexus = true;
g_player->sendInput(sent);
// The keyboard as another player's controller (Settings): its own
// slot, announced like a pad; no native mouse and keyboard then.
// Keys 2-4: that player's controller. With that player's own pad
// connected the two add up (below); alone, the keyboard is announced
// in the slot by itself.
int kbSlot = keyboardPadSlot(kbm_.keyboard || kbm_.mouse);
kbPad_ = input::ControllerState{};
if (kbSlot >= 0 && !menu_.isOpen()) input::keyboardAsGamepad(kbm_, mouseStick_, kbPad_, platform::nowMs(), keyMap_);
int alone = kbSlot >= 0 && !input::padConnected(kbSlot) ? kbSlot : -1;
if (alone != kbSlotAttached_) {
if (kbSlotAttached_ >= 0 && !input::padConnected(kbSlotAttached_)) g_player->setPadConnected(kbSlotAttached_, false);
if (alone >= 0) g_player->setPadConnected(alone, true);
kbSlotAttached_ = alone;
}
if (alone >= 0) {
g_player->sendInput(kbPad_, alone); // all released while the app's menu is open
} else if (kbSlot >= 0) {
// Added to that player's pad in the loop below.
}
if (kbSlot >= 0 && !menu_.isOpen()) {
if (touchKbm.moved) g_player->sendKbm(touchKbm);
} else if (!menu_.isOpen()) {
// USB keyboard and mouse (plus the touchpad mouse in MKB games):
// straight to the game while the app's menu is closed; F12 is the app's.
input::KbmInput toGame = kbm_;
toGame.keys.erase(std::remove_if(toGame.keys.begin(), toGame.keys.end(),
[](const input::KeyEvent& k) { return k.vk == input::kVkAppMenu || k.vk == 0x24; }),
toGame.keys.end());
for (const auto& k : toGame.keys) {
auto at = std::find(keysInGame_.begin(), keysInGame_.end(), k.vk);
if (k.pressed && at == keysInGame_.end()) keysInGame_.push_back(k.vk);
if (!k.pressed && at != keysInGame_.end()) keysInGame_.erase(at);
}
toGame.dx += touchKbm.dx;
toGame.dy += touchKbm.dy;
toGame.wheel += touchKbm.wheel;
toGame.buttons |= touchKbm.buttons;
toGame.moved |= touchKbm.moved;
g_player->sendKbm(toGame);
} else if (!keysInGame_.empty() || touchKbm.moved) {
// The menu opened with keys or a touchpad mouse button down: let go of them.
input::KbmInput release = touchKbm;
for (uint8_t vk : keysInGame_) release.keys.push_back({vk, false});
keysInGame_.clear();
g_player->sendKbm(release);
}
// The other players' controllers, straight to the game.
for (int i = 1; i < input::kMaxPads; ++i) {
input::ControllerState other;
bool on = input::pollPad(i, other);
const bool padOn = on;
input::ControllerState vpad;
bool vconn = false;
if (virtualGamepadState(i, vpad, vconn) && vconn) {
if (on) {
input::mergePads(other, vpad);
} else {
other = vpad;
on = true;
}
}
// USB pads playing as this player (pad_usb.h); theirs goes to the
// app's menu while it is open.
input::ControllerState usb;
const bool usbOn = input::pollUsbPadsFor(i, usb, menuUsbOwner());
if (usbOn && menu_.isOpen() && menuUsbOwner_ < 0) usb = input::ControllerState{};
if (usbOn) {
if (on) input::mergePads(other, usb);
else other = usb;
on = true;
}
// A USB pad alone: the app told of it as it came (app_core.cpp).
const bool usbOnly = usbOn && !padOn && !vconn;
if (on) other = input::applyPadMap(other, padMap_); // the same map as player 1's (the keys keep theirs)
if (on && i == kbSlot) input::mergePads(other, kbPad_); // the keyboard plays with this player's pad
if (on != padAttached_[i]) {
const bool quiet = on ? usbOnly : padUsbOnly_[i];
padAttached_[i] = on;
g_player->setPadConnected(i, on);
std::string who = std::to_string(i + 1);
std::string name = input::padUserName(i);
if (!name.empty()) who += " (" + name + ")";
else if (vconn && !input::padConnected(i)) who += " (Web Gamepad)";
// The PS5 user's name on the TV, not in the log.
if (!quiet)
platform::notify(ui::trf(on ? ui::Str::PadConnected : ui::Str::PadDisconnected, who),
std::string("controller ") + std::to_string(i + 1) +
(on ? " connected" : " disconnected"));
}
padUsbOnly_[i] = on && usbOnly;
if (on && platform::nowMs() < xboxUntil_[i]) other.btnNexus = true;
if (on) g_player->sendInput(other, i);
}
// The window holds the mouse while the keyboard and mouse go to the
// game (natively, or as a player's controller): not with the app's
// menu (or a system keyboard) up, nor while another window has the
// focus (the desktop shell lets go of it at once then). A no-op on
// the PS5.
setMouseCaptured_((kbm_.keyboard || kbm_.mouse) && !menu_.isOpen() && g_keyboardFor.empty() &&
shell::hasFocus());
} else {
setMouseCaptured_(false);
}
// The overlay: the menu, else the statistics line, redrawn when
// the numbers or the menu change.
uint32_t seq = g_infoSeq;
if (deband_ == 3 && seq != debandSeq_) {
// Auto block smoothing, fed once a second (auto_deband.h).
debandSeq_ = seq;
double mbps;
{
std::lock_guard<std::mutex> infoLock(g_infoMutex);
mbps = g_streamInfo.mbps;
}
if (autoDeband_.update(mbps)) {
int level = autoDeband_.level();
applyDeband_();
menu_.setDebandInUse(level);
overlaySeq_ = 0;
XC_LOGI("block smoothing auto: %s at %.1f Mbps", level == 2 ? "high" : level == 1 ? "low" : "off", mbps);
}
}
uint64_t nowMs = platform::nowMs();
bool menuRedraw = menu_.isOpen() && (nowMs - lastMenuRedrawMs_ >= 40);
// A desktop's toasts take the overlay while they last (the menu still
// comes first); the PS5's notifications are the system's.
uint64_t toasts = platform::toastsEnabled() ? platform::toasts().version(nowMs) : 0;
if (overlaySeq_ != seq + 1 || menuRedraw || toasts != toastsShown_) {
overlaySeq_ = seq + 1;
toastsShown_ = toasts;
if (menuRedraw) lastMenuRedrawMs_ = nowMs;
ui::StreamInfo info;
{
std::lock_guard<std::mutex> infoLock(g_infoMutex);
info = g_streamInfo;
}
if (menu_.isOpen()) {
float micLvl = g_player ? g_player->micLevel() : 0.0f;
bool micMuted = g_player ? (g_player->micMuted() || g_player->isMicHardwareMuted()) : false;
menu_.setMicLevel(micLvl);
menu_.setMicMuted(micMuted);
ui::Canvas c = menu_.renderMenu(info);
display::setOverlay(c.data(), ui::StreamMenu::kMenuX, ui::StreamMenu::kMenuY, c.width(), c.height(), 235);
} else if (auto shown = toasts ? platform::toasts().visible(nowMs) : std::vector<std::string>(); !shown.empty()) {
ui::Canvas c = ui::renderToastPanel(fonts_, shown);
display::setOverlay(c.data(), (static_cast<int>(display::kWidth) - c.width()) / 2, 28, c.width(), c.height(), 235);
} else if (showStats_ && seq) {
if (!info.frametimes.empty()) menu_.setFrametimes(info.frametimes);
ui::Canvas c = menu_.renderStats(info);
display::setOverlay(c.data(), ui::StreamMenu::kStatsX, ui::StreamMenu::kStatsY, c.width(), c.height(), 200);
} else if (info.degraded) {
ui::Canvas c = menu_.renderWarning();
display::setOverlay(c.data(), ui::StreamMenu::kWarnRight - c.width(), ui::StreamMenu::kWarnY, c.width(),
c.height(), 200);
} else {
display::setOverlay(nullptr, 0, 0, 0, 0, 0);
}
overlayShown_ = true;
}
}
bool StreamScreen::menuOpen() const { return menu_.isOpen(); }
void StreamScreen::redrawMenu() { overlaySeq_ = 0; }
int keyboardPadSlot(bool keyboardConnected) {
int player;
{
std::lock_guard<std::mutex> lock(g_settingsMutex);
player = g_settings.keyboardPlayer;
}
return keyboardConnected && player > 0 && player < input::kMaxPads ? player : -1;
}
void StreamScreen::idle() {
setMouseCaptured_(false); // the stream ended: the mouse is the menus' again
keysInGame_.clear();
kbSlotAttached_ = -1;
mouseStick_ = {};
if (!g_keyboardFor.empty()) updateTextInput(nullptr);
touchEnabled_ = false; // each stream starts with touch off
if (overlayShown_) {
display::setOverlay(nullptr, 0, 0, 0, 0, 0);
overlayShown_ = false;
menu_.close();
}
if (wasStreaming_) {
wasStreaming_ = false;
for (bool& a : padAttached_) a = false;
for (bool& a : padUsbOnly_) a = false;
menuUsbOwner_ = pendingUsbMenu_ = -1;
overlayPlayer_ = nullptr;
std::lock_guard<std::mutex> lock(g_settingsMutex);
input::setDeadzone(g_settings.deadzoneLeft / 100.0f, g_settings.deadzoneRight / 100.0f);
input::setTriggerFeel(g_settings.triggerStrength, g_settings.triggerHz, g_settings.triggerResistance, g_settings.triggerPulses, g_settings.triggerProfile);
input::setCircleConfirms(g_settings.circleConfirms);
if (g_ui) g_ui->setCircleConfirms(g_settings.circleConfirms);
if (highRefresh_) display::setHighRefresh(false);
highRefresh_ = false;
}
}
} // namespace xc::app