Duckstation/src/duckstation-qt/qthostinterface.h

287 lines
10 KiB
C
Raw Normal View History

2019-12-31 06:17:17 +00:00
#pragma once
#include "common/event.h"
2019-12-31 06:17:17 +00:00
#include "core/host_interface.h"
#include "core/system.h"
#include "frontend-common/common_host_interface.h"
2021-05-20 04:03:55 +00:00
#include "frontend-common/game_list.h"
#include "qtutils.h"
2020-01-07 08:55:36 +00:00
#include <QtCore/QByteArray>
#include <QtCore/QObject>
#include <QtCore/QSettings>
#include <QtCore/QString>
#include <QtCore/QThread>
#include <atomic>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
2020-01-05 02:46:03 +00:00
#include <utility>
2020-01-07 08:55:36 +00:00
#include <vector>
class ByteStream;
2019-12-31 06:17:17 +00:00
2021-03-27 04:14:52 +00:00
class QActionGroup;
class QEventLoop;
2020-02-15 15:14:04 +00:00
class QMenu;
2019-12-31 06:17:17 +00:00
class QWidget;
class QTimer;
class QTranslator;
2019-12-31 06:17:17 +00:00
class INISettingsInterface;
2019-12-31 06:17:17 +00:00
class MainWindow;
class QtDisplayWidget;
Q_DECLARE_METATYPE(std::shared_ptr<const SystemBootParameters>);
2021-05-20 04:03:55 +00:00
Q_DECLARE_METATYPE(const GameListEntry*);
Q_DECLARE_METATYPE(GPURenderer);
class QtHostInterface final : public QObject, public CommonHostInterface
2019-12-31 06:17:17 +00:00
{
Q_OBJECT
public:
explicit QtHostInterface(QObject* parent = nullptr);
~QtHostInterface();
ALWAYS_INLINE static QtHostInterface* GetInstance() { return static_cast<QtHostInterface*>(g_host_interface); }
const char* GetFrontendName() const override;
bool Initialize() override;
void Shutdown() override;
2020-10-09 08:26:21 +00:00
public Q_SLOTS:
2019-12-31 06:17:17 +00:00
void ReportError(const char* message) override;
void ReportMessage(const char* message) override;
void ReportDebuggerMessage(const char* message) override;
bool ConfirmMessage(const char* message) override;
2019-12-31 06:17:17 +00:00
2020-10-09 08:26:21 +00:00
public:
/// Thread-safe settings access.
void SetBoolSettingValue(const char* section, const char* key, bool value);
void SetIntSettingValue(const char* section, const char* key, int value);
void SetFloatSettingValue(const char* section, const char* key, float value);
void SetStringSettingValue(const char* section, const char* key, const char* value);
void SetStringListSettingValue(const char* section, const char* key, const std::vector<std::string>& values);
void RemoveSettingValue(const char* section, const char* key);
2019-12-31 06:17:17 +00:00
TinyString TranslateString(const char* context, const char* str, const char* disambiguation = nullptr,
int n = -1) const override;
std::string TranslateStdString(const char* context, const char* str, const char* disambiguation = nullptr,
int n = -1) const override;
2020-11-18 13:15:16 +00:00
bool RequestRenderWindowSize(s32 new_window_width, s32 new_window_height) override;
void* GetTopLevelWindowHandle() const override;
2020-11-18 13:15:16 +00:00
ALWAYS_INLINE const GameList* getGameList() const { return m_game_list.get(); }
ALWAYS_INLINE GameList* getGameList() { return m_game_list.get(); }
2020-01-08 03:37:43 +00:00
void refreshGameList(bool invalidate_cache = false, bool invalidate_database = false);
2019-12-31 06:17:17 +00:00
ALWAYS_INLINE const HotkeyInfoList& getHotkeyInfoList() const { return GetHotkeyInfoList(); }
ALWAYS_INLINE ControllerInterface* getControllerInterface() const { return GetControllerInterface(); }
ALWAYS_INLINE bool inBatchMode() const { return InBatchMode(); }
2020-08-06 12:08:22 +00:00
ALWAYS_INLINE void requestExit() { RequestExit(); }
ALWAYS_INLINE bool isOnWorkerThread() const { return QThread::currentThread() == m_worker_thread; }
2019-12-31 06:17:17 +00:00
ALWAYS_INLINE MainWindow* getMainWindow() const { return m_main_window; }
void setMainWindow(MainWindow* window);
HostDisplay* createHostDisplay();
2019-12-31 06:17:17 +00:00
2020-02-15 15:14:04 +00:00
void populateSaveStateMenus(const char* game_code, QMenu* load_menu, QMenu* save_menu);
/// Fills menu with save state info and handlers.
void populateGameListContextMenu(const GameListEntry* entry, QWidget* parent_window, QMenu* menu);
2020-08-15 10:39:11 +00:00
/// Fills menu with the current playlist entries. The disc index is marked as checked.
2021-03-27 04:14:52 +00:00
void populateChangeDiscSubImageMenu(QMenu* menu, QActionGroup* action_group);
2020-08-15 10:39:11 +00:00
2020-09-09 13:44:21 +00:00
/// Fills menu with the current cheat options.
void populateCheatsMenu(QMenu* menu);
ALWAYS_INLINE QString getSavePathForInputProfile(const QString& name) const
{
return QString::fromStdString(GetSavePathForInputProfile(name.toUtf8().constData()));
2020-04-14 15:44:16 +00:00
}
ALWAYS_INLINE InputProfileList getInputProfileList() const { return GetInputProfileList(); }
2020-04-14 15:44:16 +00:00
void saveInputProfile(const QString& profile_path);
/// Returns a path relative to the user directory.
QString getUserDirectoryRelativePath(const QString& arg) const;
/// Returns a path relative to the application directory (for system files).
QString getProgramDirectoryRelativePath(const QString& arg) const;
/// Returns a list of supported languages and codes (suffixes for translation files).
static std::vector<std::pair<QString, QString>> getAvailableLanguageList();
2020-08-06 12:08:22 +00:00
/// Returns program directory as a QString.
QString getProgramDirectory() const;
2019-12-31 06:17:17 +00:00
Q_SIGNALS:
void errorReported(const QString& message);
void messageReported(const QString& message);
void debuggerMessageReported(const QString& message);
bool messageConfirmed(const QString& message);
void emulationStarting();
2019-12-31 06:17:17 +00:00
void emulationStarted();
void emulationStopped();
void emulationPaused(bool paused);
void stateSaved(const QString& game_code, bool global, qint32 slot);
2019-12-31 06:17:17 +00:00
void gameListRefreshed();
QtDisplayWidget* createDisplayRequested(QThread* worker_thread, bool fullscreen, bool render_to_main);
QtDisplayWidget* updateDisplayRequested(QThread* worker_thread, bool fullscreen, bool render_to_main);
2020-11-18 13:15:16 +00:00
void displaySizeRequested(qint32 width, qint32 height);
void focusDisplayWidgetRequested();
void destroyDisplayRequested();
void systemPerformanceCountersUpdated(float speed, float fps, float vps, float avg_frame_time, float worst_frame_time,
GPURenderer renderer, quint32 render_width, quint32 render_height,
bool render_interlaced);
void runningGameChanged(const QString& filename, const QString& game_code, const QString& game_title);
void exitRequested();
2020-04-14 15:44:16 +00:00
void inputProfileLoaded();
2020-12-27 04:08:13 +00:00
void mouseModeRequested(bool relative, bool hide_cursor);
2021-02-26 14:44:53 +00:00
void achievementsLoaded(quint32 id, const QString& game_info_string, quint32 total, quint32 points);
2019-12-31 06:17:17 +00:00
public Q_SLOTS:
void setDefaultSettings();
void applySettings(bool display_osd_messages = false);
void updateInputMap();
2020-04-14 15:44:16 +00:00
void applyInputProfile(const QString& profile_path);
void bootSystem(std::shared_ptr<const SystemBootParameters> params);
void resumeSystemFromState(const QString& filename, bool boot_on_failure);
2020-05-23 05:03:00 +00:00
void resumeSystemFromMostRecentState();
void powerOffSystem();
void powerOffSystemWithoutSaving();
void synchronousPowerOffSystem();
2019-12-31 06:17:17 +00:00
void resetSystem();
2020-12-16 15:18:13 +00:00
void pauseSystem(bool paused, bool wait_until_paused = false);
void changeDisc(const QString& new_disc_filename);
2020-08-15 10:39:11 +00:00
void changeDiscFromPlaylist(quint32 index);
void loadState(const QString& filename);
2020-02-15 15:14:04 +00:00
void loadState(bool global, qint32 slot);
void saveState(bool global, qint32 slot, bool block_until_done = false);
void setAudioOutputVolume(int volume, int fast_forward_volume);
void setAudioOutputMuted(bool muted);
2020-03-15 12:04:32 +00:00
void startDumpingAudio();
void stopDumpingAudio();
2020-12-16 15:18:13 +00:00
void singleStepCPU();
void dumpRAM(const QString& filename);
2021-01-13 09:24:41 +00:00
void dumpVRAM(const QString& filename);
void dumpSPURAM(const QString& filename);
2020-03-15 14:06:39 +00:00
void saveScreenshot();
void redrawDisplayWindow();
void toggleFullscreen();
2020-09-09 13:44:21 +00:00
void loadCheatList(const QString& filename);
void setCheatEnabled(quint32 index, bool enabled);
void applyCheat(quint32 index);
void reloadPostProcessingShaders();
2020-11-18 13:15:16 +00:00
void requestRenderWindowScale(qreal scale);
2020-10-19 15:14:49 +00:00
void executeOnEmulationThread(std::function<void()> callback, bool wait = false);
2021-02-26 14:44:53 +00:00
void OnAchievementsRefreshed() override;
2019-12-31 06:17:17 +00:00
private Q_SLOTS:
void doStopThread();
2021-02-25 16:42:20 +00:00
void onDisplayWindowMouseMoveEvent(int x, int y);
void onDisplayWindowMouseButtonEvent(int button, bool pressed);
void onDisplayWindowMouseWheelEvent(const QPoint& delta_angle);
void onDisplayWindowResized(int width, int height);
void onDisplayWindowFocused();
void onDisplayWindowKeyEvent(int key, int mods, bool pressed);
void doBackgroundControllerPoll();
2020-07-21 09:58:50 +00:00
void doSaveSettings();
2019-12-31 06:17:17 +00:00
protected:
bool AcquireHostDisplay() override;
void ReleaseHostDisplay() override;
bool IsFullscreen() const override;
bool SetFullscreen(bool enabled) override;
void RequestExit() override;
std::optional<HostKeyCode> GetHostKeyCode(const std::string_view key_code) const override;
void OnSystemCreated() override;
void OnSystemPaused(bool paused) override;
void OnSystemDestroyed() override;
void OnSystemPerformanceCountersUpdated() override;
void OnRunningGameChanged(const std::string& path, CDImage* image, const std::string& game_code,
const std::string& game_title) override;
void OnSystemStateSaved(bool global, s32 slot) override;
void SetDefaultSettings(SettingsInterface& si) override;
void ApplySettings(bool display_osd_messages) override;
2020-12-27 04:08:13 +00:00
void SetMouseMode(bool relative, bool hide_cursor) override;
void RunLater(std::function<void()> func) override;
2020-12-27 04:08:13 +00:00
2019-12-31 06:17:17 +00:00
private:
enum : u32
{
BACKGROUND_CONTROLLER_POLLING_INTERVAL =
2020-07-21 09:58:50 +00:00
100, /// Interval at which the controllers are polled when the system is not active.
SETTINGS_SAVE_DELAY = 1000,
/// Crappy solution to the Qt indices being massive.
IMGUI_KEY_MASK = 511,
};
2020-01-05 02:46:03 +00:00
using InputButtonHandler = std::function<void(bool)>;
2020-02-17 15:06:28 +00:00
using InputAxisHandler = std::function<void(float)>;
2020-01-05 02:46:03 +00:00
2019-12-31 06:17:17 +00:00
class Thread : public QThread
{
public:
Thread(QtHostInterface* parent);
~Thread();
void setInitResult(bool result);
bool waitForInit();
2019-12-31 06:17:17 +00:00
protected:
void run() override;
private:
QtHostInterface* m_parent;
std::atomic_bool m_init_result{false};
Common::Event m_init_event;
2019-12-31 06:17:17 +00:00
};
void createBackgroundControllerPollTimer();
void destroyBackgroundControllerPollTimer();
void startBackgroundControllerPollTimer();
void stopBackgroundControllerPollTimer();
void setImGuiFont();
void setImGuiKeyMap();
2019-12-31 06:17:17 +00:00
void createThread();
void stopThread();
void threadEntryPoint();
bool initializeOnThread();
void shutdownOnThread();
void installTranslator();
void renderDisplay();
void connectDisplaySignals(QtDisplayWidget* widget);
void updateDisplayState();
2020-07-21 09:58:50 +00:00
void queueSettingsSave();
void wakeThread();
2019-12-31 06:17:17 +00:00
MainWindow* m_main_window = nullptr;
2019-12-31 06:17:17 +00:00
QThread* m_original_thread = nullptr;
Thread* m_worker_thread = nullptr;
QEventLoop* m_worker_thread_event_loop = nullptr;
2020-10-19 15:14:49 +00:00
Common::Event m_worker_thread_sync_execute_done;
2019-12-31 06:17:17 +00:00
std::atomic_bool m_shutdown_flag{false};
2019-12-31 06:17:17 +00:00
QTimer* m_background_controller_polling_timer = nullptr;
2020-07-21 09:58:50 +00:00
std::unique_ptr<QTimer> m_settings_save_timer;
bool m_is_rendering_to_main = false;
bool m_is_fullscreen = false;
bool m_is_exclusive_fullscreen = false;
bool m_lost_exclusive_fullscreen = false;
};