diff options
Diffstat (limited to 'src/citron/bootmanager.h')
| -rw-r--r-- | src/citron/bootmanager.h | 280 |
1 files changed, 280 insertions, 0 deletions
diff --git a/src/citron/bootmanager.h b/src/citron/bootmanager.h new file mode 100644 index 000000000..ae12b3481 --- /dev/null +++ b/src/citron/bootmanager.h @@ -0,0 +1,280 @@ +// SPDX-FileCopyrightText: 2014 Citra Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include <condition_variable> +#include <cstddef> +#include <memory> +#include <mutex> +#include <utility> +#include <vector> + +#include <QByteArray> +#include <QImage> +#include <QObject> +#include <QPoint> +#include <QString> +#include <QStringList> +#include <QThread> +#include <QTimer> +#include <QWidget> +#include <qglobal.h> +#include <qnamespace.h> +#include <qobjectdefs.h> + +#include "common/common_types.h" +#include "common/logging/log.h" +#include "common/polyfill_thread.h" +#include "common/thread.h" +#include "core/frontend/emu_window.h" + +class GMainWindow; +class QCamera; +class QCameraImageCapture; +class QCloseEvent; +class QFocusEvent; +class QKeyEvent; +class QMouseEvent; +class QObject; +class QResizeEvent; +class QShowEvent; +class QTouchEvent; +class QWheelEvent; + +namespace Core { +class System; +} // namespace Core + +namespace InputCommon { +class InputSubsystem; +enum class MouseButton; +} // namespace InputCommon + +namespace InputCommon::TasInput { +enum class TasState; +} // namespace InputCommon::TasInput + +namespace VideoCore { +enum class LoadCallbackStage; +} // namespace VideoCore + +class EmuThread final : public QThread { + Q_OBJECT + +public: + explicit EmuThread(Core::System& system); + ~EmuThread() override; + + /** + * Start emulation (on new thread) + * @warning Only call when not running! + */ + void run() override; + + /** + * Sets whether the emulation thread should run or not + * @param should_run Boolean value, set the emulation thread to running if true + */ + void SetRunning(bool should_run) { + // TODO: Prevent other threads from modifying the state until we finish. + { + // Notify the running thread to change state. + std::unique_lock run_lk{m_should_run_mutex}; + m_should_run = should_run; + m_should_run_cv.notify_one(); + } + + // Wait until paused, if pausing. + if (!should_run) { + m_stopped.Wait(); + } + } + + /** + * Check if the emulation thread is running or not + * @return True if the emulation thread is running, otherwise false + */ + bool IsRunning() const { + return m_should_run; + } + + /** + * Requests for the emulation thread to immediately stop running + */ + void ForceStop() { + LOG_WARNING(Frontend, "Force stopping EmuThread"); + m_stop_source.request_stop(); + } + +private: + void EmulationPaused(std::unique_lock<std::mutex>& lk); + void EmulationResumed(std::unique_lock<std::mutex>& lk); + +private: + Core::System& m_system; + + std::stop_source m_stop_source; + std::mutex m_should_run_mutex; + std::condition_variable_any m_should_run_cv; + Common::Event m_stopped; + bool m_should_run{true}; + +signals: + /** + * Emitted when the CPU has halted execution + * + * @warning When connecting to this signal from other threads, make sure to specify either + * Qt::QueuedConnection (invoke slot within the destination object's message thread) or even + * Qt::BlockingQueuedConnection (additionally block source thread until slot returns) + */ + void DebugModeEntered(); + + /** + * Emitted right before the CPU continues execution + * + * @warning When connecting to this signal from other threads, make sure to specify either + * Qt::QueuedConnection (invoke slot within the destination object's message thread) or even + * Qt::BlockingQueuedConnection (additionally block source thread until slot returns) + */ + void DebugModeLeft(); + + void LoadProgress(VideoCore::LoadCallbackStage stage, std::size_t value, std::size_t total); +}; + +class GRenderWindow : public QWidget, public Core::Frontend::EmuWindow { + Q_OBJECT + +public: + explicit GRenderWindow(GMainWindow* parent, EmuThread* emu_thread_, + std::shared_ptr<InputCommon::InputSubsystem> input_subsystem_, + Core::System& system_); + ~GRenderWindow() override; + + // EmuWindow implementation. + void OnFrameDisplayed() override; + bool IsShown() const override; + std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override; + + void BackupGeometry(); + void RestoreGeometry(); + void restoreGeometry(const QByteArray& geometry_); // overridden + QByteArray saveGeometry(); // overridden + + qreal windowPixelRatio() const; + + std::pair<u32, u32> ScaleTouch(const QPointF& pos) const; + + void closeEvent(QCloseEvent* event) override; + void leaveEvent(QEvent* event) override; + + void resizeEvent(QResizeEvent* event) override; + + /// Converts a Qt keyboard key into NativeKeyboard key + static int QtKeyToSwitchKey(Qt::Key qt_keys); + + /// Converts a Qt modifier keys into NativeKeyboard modifier keys + static int QtModifierToSwitchModifier(Qt::KeyboardModifiers qt_modifiers); + + void keyPressEvent(QKeyEvent* event) override; + void keyReleaseEvent(QKeyEvent* event) override; + + /// Converts a Qt mouse button into MouseInput mouse button + static InputCommon::MouseButton QtButtonToMouseButton(Qt::MouseButton button); + + void mousePressEvent(QMouseEvent* event) override; + void mouseMoveEvent(QMouseEvent* event) override; + void mouseReleaseEvent(QMouseEvent* event) override; + void wheelEvent(QWheelEvent* event) override; + + void InitializeCamera(); + void FinalizeCamera(); + + bool event(QEvent* event) override; + + void focusOutEvent(QFocusEvent* event) override; + + bool InitRenderTarget(); + + /// Destroy the previous run's child_widget which should also destroy the child_window + void ReleaseRenderTarget(); + + bool IsLoadingComplete() const; + + void CaptureScreenshot(const QString& screenshot_path); + + /** + * Instructs the window to re-launch the application using the specified program_index. + * @param program_index Specifies the index within the application of the program to launch. + */ + void ExecuteProgram(std::size_t program_index); + + /// Instructs the window to exit the application. + void Exit(); + +public slots: + void OnEmulationStarting(EmuThread* emu_thread_); + void OnEmulationStopping(); + void OnFramebufferSizeChanged(); + +signals: + /// Emitted when the window is closed + void Closed(); + void FirstFrameDisplayed(); + void ExecuteProgramSignal(std::size_t program_index); + void ExitSignal(); + void MouseActivity(); + void TasPlaybackStateChanged(); + +private: + void TouchBeginEvent(const QTouchEvent* event); + void TouchUpdateEvent(const QTouchEvent* event); + void TouchEndEvent(); + void ConstrainMouse(); + + void RequestCameraCapture(); + void OnCameraCapture(int requestId, const QImage& img); + + void OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) override; + + bool InitializeOpenGL(); + bool InitializeVulkan(); + void InitializeNull(); + bool LoadOpenGL(); + QStringList GetUnsupportedGLExtensions() const; + + EmuThread* emu_thread; + std::shared_ptr<InputCommon::InputSubsystem> input_subsystem; + + // Main context that will be shared with all other contexts that are requested. + // If this is used in a shared context setting, then this should not be used directly, but + // should instead be shared from + std::shared_ptr<Core::Frontend::GraphicsContext> main_context; + + /// Temporary storage of the screenshot taken + QImage screenshot_image; + + QByteArray geometry; + + QWidget* child_widget = nullptr; + + bool first_frame = false; + InputCommon::TasInput::TasState last_tas_state; + +#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) && YUZU_USE_QT_MULTIMEDIA + bool is_virtual_camera; + int pending_camera_snapshots; + std::vector<u32> camera_data; + std::unique_ptr<QCamera> camera; + std::unique_ptr<QCameraImageCapture> camera_capture; + std::unique_ptr<QTimer> camera_timer; +#endif + + QTimer mouse_constrain_timer; + + Core::System& system; + +protected: + void showEvent(QShowEvent* event) override; + bool eventFilter(QObject* object, QEvent* event) override; +}; |