diff options
Diffstat (limited to '')
39 files changed, 712 insertions, 243 deletions
diff --git a/.travis-upload.sh b/.travis-upload.sh index 3a15e8f6a..e508386dd 100755 --- a/.travis-upload.sh +++ b/.travis-upload.sh @@ -24,5 +24,5 @@ if [ "$TRAVIS_BRANCH" = "master" ]; then ARCHIVE_NAME="${REV_NAME}.tar.xz" tar -cJvf "$ARCHIVE_NAME" "$REV_NAME" - lftp -c "open -u citra-builds,$BUILD_PASSWORD sftp://builds.citra-emu.org; put -O '$UPLOAD_DIR' '$ARCHIVE_NAME'" + lftp -c "open -u citra-builds,$BUILD_PASSWORD sftp://builds.citra-emu.org; set sftp:auto-confirm yes; put -O '$UPLOAD_DIR' '$ARCHIVE_NAME'" fi diff --git a/appveyor.yml b/appveyor.yml index 6e073ece7..d05cc2213 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -2,7 +2,6 @@ clone_depth: 5 environment: - QTDIR: C:\Qt\5.4\msvc2013_64_opengl BUILD_PASSWORD: secure: EXGNlWKJsCtbeImEJ5EP9qrxZ+EqUFfNy+CP61nDOMA= @@ -18,7 +17,7 @@ install: before_build: - mkdir build - cd build - - cmake -G "Visual Studio 12 Win64" -DCITRA_USE_BUNDLED_GLFW=1 -DQt5_DIR=%QTDIR%/lib/cmake/Qt5 .. + - cmake -G "Visual Studio 14 Win64" -DCITRA_USE_BUNDLED_GLFW=1 -DCITRA_USE_BUNDLED_QT=1 .. - cd .. after_build: diff --git a/src/citra/citra.cpp b/src/citra/citra.cpp index b36865395..bfbb21199 100644 --- a/src/citra/citra.cpp +++ b/src/citra/citra.cpp @@ -74,6 +74,7 @@ int main(int argc, char **argv) { Config config; log_filter.ParseFilterString(Settings::values.log_filter); + GDBStub::ToggleServer(Settings::values.use_gdbstub); GDBStub::SetServerPort(static_cast<u32>(Settings::values.gdbstub_port)); EmuWindow_GLFW* emu_window = new EmuWindow_GLFW; diff --git a/src/citra_qt/CMakeLists.txt b/src/citra_qt/CMakeLists.txt index a82e8a85b..51a574629 100644 --- a/src/citra_qt/CMakeLists.txt +++ b/src/citra_qt/CMakeLists.txt @@ -17,6 +17,7 @@ set(SRCS debugger/profiler.cpp debugger/ramview.cpp debugger/registers.cpp + game_list.cpp util/spinbox.cpp util/util.cpp bootmanager.cpp @@ -42,6 +43,7 @@ set(HEADERS debugger/profiler.h debugger/ramview.h debugger/registers.h + game_list.h util/spinbox.h util/util.h bootmanager.h diff --git a/src/citra_qt/bootmanager.cpp b/src/citra_qt/bootmanager.cpp index 7a1360d34..b19b367e1 100644 --- a/src/citra_qt/bootmanager.cpp +++ b/src/citra_qt/bootmanager.cpp @@ -19,8 +19,8 @@ #include "core/settings.h" #include "core/system.h" -#include "video_core/video_core.h" #include "video_core/debug_utils/debug_utils.h" +#include "video_core/video_core.h" #define APP_NAME "citra" #define APP_VERSION "0.1-" VERSION @@ -86,6 +86,9 @@ public: } void paintEvent(QPaintEvent* ev) override { + if (do_painting) { + QPainter painter(this); + } } void resizeEvent(QResizeEvent* ev) override { @@ -93,8 +96,12 @@ public: parent->OnFramebufferSizeChanged(); } + void DisablePainting() { do_painting = false; } + void EnablePainting() { do_painting = true; } + private: GRenderWindow* parent; + bool do_painting; }; GRenderWindow::GRenderWindow(QWidget* parent, EmuThread* emu_thread) : @@ -128,9 +135,6 @@ GRenderWindow::GRenderWindow(QWidget* parent, EmuThread* emu_thread) : BackupGeometry(); -#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) - connect(this->windowHandle(), SIGNAL(screenChanged(QScreen*)), this, SLOT(OnFramebufferSizeChanged())); -#endif } void GRenderWindow::moveContext() @@ -273,8 +277,19 @@ void GRenderWindow::OnMinimalClientAreaChangeRequest(const std::pair<unsigned,un void GRenderWindow::OnEmulationStarting(EmuThread* emu_thread) { this->emu_thread = emu_thread; + child->DisablePainting(); } void GRenderWindow::OnEmulationStopping() { emu_thread = nullptr; + child->EnablePainting(); +} + +void GRenderWindow::showEvent(QShowEvent * event) { + QWidget::showEvent(event); + + // windowHandle() is not initialized until the Window is shown, so we connect it here. + #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) + connect(this->windowHandle(), SIGNAL(screenChanged(QScreen*)), this, SLOT(OnFramebufferSizeChanged()), Qt::UniqueConnection); + #endif } diff --git a/src/citra_qt/bootmanager.h b/src/citra_qt/bootmanager.h index dc422358e..0a9d263b8 100644 --- a/src/citra_qt/bootmanager.h +++ b/src/citra_qt/bootmanager.h @@ -12,11 +12,12 @@ #include "common/emu_window.h" #include "common/thread.h" -class QScreen; class QKeyEvent; +class QScreen; -class GRenderWindow; +class GGLWidgetInternal; class GMainWindow; +class GRenderWindow; class EmuThread : public QThread { @@ -123,13 +124,12 @@ public: void OnClientAreaResized(unsigned width, unsigned height); - void OnFramebufferSizeChanged(); - public slots: void moveContext(); // overridden void OnEmulationStarting(EmuThread* emu_thread); void OnEmulationStopping(); + void OnFramebufferSizeChanged(); signals: /// Emitted when the window is closed @@ -138,7 +138,7 @@ signals: private: void OnMinimalClientAreaChangeRequest(const std::pair<unsigned,unsigned>& minimal_size) override; - QGLWidget* child; + GGLWidgetInternal* child; QByteArray geometry; @@ -146,4 +146,7 @@ private: int keyboard_id; EmuThread* emu_thread; + +protected: + void showEvent(QShowEvent* event) override; }; diff --git a/src/citra_qt/game_list.cpp b/src/citra_qt/game_list.cpp new file mode 100644 index 000000000..dade3c212 --- /dev/null +++ b/src/citra_qt/game_list.cpp @@ -0,0 +1,171 @@ +// Copyright 2015 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include <QHeaderView> +#include <QThreadPool> +#include <QVBoxLayout> + +#include "game_list.h" +#include "game_list_p.h" + +#include "core/loader/loader.h" + +#include "common/common_paths.h" +#include "common/logging/log.h" +#include "common/string_util.h" + +GameList::GameList(QWidget* parent) +{ + QVBoxLayout* layout = new QVBoxLayout; + + tree_view = new QTreeView; + item_model = new QStandardItemModel(tree_view); + tree_view->setModel(item_model); + + tree_view->setAlternatingRowColors(true); + tree_view->setSelectionMode(QHeaderView::SingleSelection); + tree_view->setSelectionBehavior(QHeaderView::SelectRows); + tree_view->setVerticalScrollMode(QHeaderView::ScrollPerPixel); + tree_view->setHorizontalScrollMode(QHeaderView::ScrollPerPixel); + tree_view->setSortingEnabled(true); + tree_view->setEditTriggers(QHeaderView::NoEditTriggers); + tree_view->setUniformRowHeights(true); + + item_model->insertColumns(0, COLUMN_COUNT); + item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, "File type"); + item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, "Name"); + item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, "Size"); + + connect(tree_view, SIGNAL(activated(const QModelIndex&)), this, SLOT(ValidateEntry(const QModelIndex&))); + + // We must register all custom types with the Qt Automoc system so that we are able to use it with + // signals/slots. In this case, QList falls under the umbrells of custom types. + qRegisterMetaType<QList<QStandardItem*>>("QList<QStandardItem*>"); + + layout->addWidget(tree_view); + setLayout(layout); +} + +GameList::~GameList() +{ + emit ShouldCancelWorker(); +} + +void GameList::AddEntry(QList<QStandardItem*> entry_items) +{ + item_model->invisibleRootItem()->appendRow(entry_items); +} + +void GameList::ValidateEntry(const QModelIndex& item) +{ + // We don't care about the individual QStandardItem that was selected, but its row. + int row = item_model->itemFromIndex(item)->row(); + QStandardItem* child_file = item_model->invisibleRootItem()->child(row, COLUMN_NAME); + QString file_path = child_file->data(GameListItemPath::FullPathRole).toString(); + + if (file_path.isEmpty()) + return; + std::string std_file_path = file_path.toStdString(); + if (!FileUtil::Exists(std_file_path) || FileUtil::IsDirectory(std_file_path)) + return; + emit GameChosen(file_path); +} + +void GameList::DonePopulating() +{ + tree_view->setEnabled(true); +} + +void GameList::PopulateAsync(const QString& dir_path, bool deep_scan) +{ + if (!FileUtil::Exists(dir_path.toStdString()) || !FileUtil::IsDirectory(dir_path.toStdString())) { + LOG_ERROR(Frontend, "Could not find game list folder at %s", dir_path.toLatin1().data()); + return; + } + + tree_view->setEnabled(false); + // Delete any rows that might already exist if we're repopulating + item_model->removeRows(0, item_model->rowCount()); + + emit ShouldCancelWorker(); + GameListWorker* worker = new GameListWorker(dir_path, deep_scan); + + connect(worker, SIGNAL(EntryReady(QList<QStandardItem*>)), this, SLOT(AddEntry(QList<QStandardItem*>)), Qt::QueuedConnection); + connect(worker, SIGNAL(Finished()), this, SLOT(DonePopulating()), Qt::QueuedConnection); + // Use DirectConnection here because worker->Cancel() is thread-safe and we want it to cancel without delay. + connect(this, SIGNAL(ShouldCancelWorker()), worker, SLOT(Cancel()), Qt::DirectConnection); + + QThreadPool::globalInstance()->start(worker); + current_worker = std::move(worker); +} + +void GameList::SaveInterfaceLayout(QSettings& settings) +{ + settings.beginGroup("UILayout"); + settings.setValue("gameListHeaderState", tree_view->header()->saveState()); + settings.endGroup(); +} + +void GameList::LoadInterfaceLayout(QSettings& settings) +{ + auto header = tree_view->header(); + settings.beginGroup("UILayout"); + header->restoreState(settings.value("gameListHeaderState").toByteArray()); + settings.endGroup(); + + item_model->sort(header->sortIndicatorSection(), header->sortIndicatorOrder()); +} + +void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, bool deep_scan) +{ + const auto callback = [&](const std::string& directory, + const std::string& virtual_name) -> int { + + std::string physical_name = directory + DIR_SEP + virtual_name; + + if (stop_processing) + return -1; // A negative return value breaks the callback loop. + + if (deep_scan && FileUtil::IsDirectory(physical_name)) { + AddFstEntriesToGameList(physical_name, true); + } else { + std::string filename_filename, filename_extension; + Common::SplitPath(physical_name, nullptr, &filename_filename, &filename_extension); + + Loader::FileType guessed_filetype = Loader::GuessFromExtension(filename_extension); + if (guessed_filetype == Loader::FileType::Unknown) + return 0; + Loader::FileType filetype = Loader::IdentifyFile(physical_name); + if (filetype == Loader::FileType::Unknown) { + LOG_WARNING(Frontend, "File %s is of indeterminate type and is possibly corrupted.", physical_name.c_str()); + return 0; + } + if (guessed_filetype != filetype) { + LOG_WARNING(Frontend, "Filetype and extension of file %s do not match.", physical_name.c_str()); + } + + emit EntryReady({ + new GameListItem(QString::fromStdString(Loader::GetFileTypeString(filetype))), + new GameListItemPath(QString::fromStdString(physical_name)), + new GameListItemSize(FileUtil::GetSize(physical_name)), + }); + } + + return 0; // We don't care about the found entries + }; + FileUtil::ScanDirectoryTreeAndCallback(dir_path, callback); +} + +void GameListWorker::run() +{ + stop_processing = false; + AddFstEntriesToGameList(dir_path.toStdString(), deep_scan); + emit Finished(); +} + +void GameListWorker::Cancel() +{ + disconnect(this, 0, 0, 0); + stop_processing = true; +} diff --git a/src/citra_qt/game_list.h b/src/citra_qt/game_list.h new file mode 100644 index 000000000..0950d9622 --- /dev/null +++ b/src/citra_qt/game_list.h @@ -0,0 +1,52 @@ +// Copyright 2015 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include <QModelIndex> +#include <QSettings> +#include <QStandardItem> +#include <QStandardItemModel> +#include <QString> +#include <QTreeView> +#include <QWidget> + +class GameListWorker; + + +class GameList : public QWidget { + Q_OBJECT + +public: + enum { + COLUMN_FILE_TYPE, + COLUMN_NAME, + COLUMN_SIZE, + COLUMN_COUNT, // Number of columns + }; + + GameList(QWidget* parent = nullptr); + ~GameList() override; + + void PopulateAsync(const QString& dir_path, bool deep_scan); + + void SaveInterfaceLayout(QSettings& settings); + void LoadInterfaceLayout(QSettings& settings); + +public slots: + void AddEntry(QList<QStandardItem*> entry_items); + +private slots: + void ValidateEntry(const QModelIndex& item); + void DonePopulating(); + +signals: + void GameChosen(QString game_path); + void ShouldCancelWorker(); + +private: + QTreeView* tree_view = nullptr; + QStandardItemModel* item_model = nullptr; + GameListWorker* current_worker = nullptr; +}; diff --git a/src/citra_qt/game_list_p.h b/src/citra_qt/game_list_p.h new file mode 100644 index 000000000..820012bce --- /dev/null +++ b/src/citra_qt/game_list_p.h @@ -0,0 +1,130 @@ +// Copyright 2015 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include <atomic> + +#include <QRunnable> +#include <QStandardItem> +#include <QString> + +#include "citra_qt/util/util.h" +#include "common/string_util.h" + + +class GameListItem : public QStandardItem { + +public: + GameListItem(): QStandardItem() {} + GameListItem(const QString& string): QStandardItem(string) {} + virtual ~GameListItem() override {} +}; + + +/** + * A specialization of GameListItem for path values. + * This class ensures that for every full path value it holds, a correct string representation + * of just the filename (with no extension) will be displayed to the user. + */ +class GameListItemPath : public GameListItem { + +public: + static const int FullPathRole = Qt::UserRole + 1; + + GameListItemPath(): GameListItem() {} + GameListItemPath(const QString& game_path): GameListItem() + { + setData(game_path, FullPathRole); + } + + void setData(const QVariant& value, int role) override + { + // By specializing setData for FullPathRole, we can ensure that the two string + // representations of the data are always accurate and in the correct format. + if (role == FullPathRole) { + std::string filename; + Common::SplitPath(value.toString().toStdString(), nullptr, &filename, nullptr); + GameListItem::setData(QString::fromStdString(filename), Qt::DisplayRole); + GameListItem::setData(value, FullPathRole); + } else { + GameListItem::setData(value, role); + } + } +}; + + +/** + * A specialization of GameListItem for size values. + * This class ensures that for every numerical size value it holds (in bytes), a correct + * human-readable string representation will be displayed to the user. + */ +class GameListItemSize : public GameListItem { + +public: + static const int SizeRole = Qt::UserRole + 1; + + GameListItemSize(): GameListItem() {} + GameListItemSize(const qulonglong size_bytes): GameListItem() + { + setData(size_bytes, SizeRole); + } + + void setData(const QVariant& value, int role) override + { + // By specializing setData for SizeRole, we can ensure that the numerical and string + // representations of the data are always accurate and in the correct format. + if (role == SizeRole) { + qulonglong size_bytes = value.toULongLong(); + GameListItem::setData(ReadableByteSize(size_bytes), Qt::DisplayRole); + GameListItem::setData(value, SizeRole); + } else { + GameListItem::setData(value, role); + } + } + + /** + * This operator is, in practice, only used by the TreeView sorting systems. + * Override it so that it will correctly sort by numerical value instead of by string representation. + */ + bool operator<(const QStandardItem& other) const override + { + return data(SizeRole).toULongLong() < other.data(SizeRole).toULongLong(); + } +}; + + +/** + * Asynchronous worker object for populating the game list. + * Communicates with other threads through Qt's signal/slot system. + */ +class GameListWorker : public QObject, public QRunnable { + Q_OBJECT + +public: + GameListWorker(QString dir_path, bool deep_scan): + QObject(), QRunnable(), dir_path(dir_path), deep_scan(deep_scan) {} + +public slots: + /// Starts the processing of directory tree information. + void run() override; + /// Tells the worker that it should no longer continue processing. Thread-safe. + void Cancel(); + +signals: + /** + * The `EntryReady` signal is emitted once an entry has been prepared and is ready + * to be added to the game list. + * @param entry_items a list with `QStandardItem`s that make up the columns of the new entry. + */ + void EntryReady(QList<QStandardItem*> entry_items); + void Finished(); + +private: + QString dir_path; + bool deep_scan; + std::atomic_bool stop_processing; + + void AddFstEntriesToGameList(const std::string& dir_path, bool deep_scan); +}; diff --git a/src/citra_qt/main.cpp b/src/citra_qt/main.cpp index e032cf639..d8d17f466 100644 --- a/src/citra_qt/main.cpp +++ b/src/citra_qt/main.cpp @@ -12,6 +12,7 @@ #include "citra_qt/bootmanager.h" #include "citra_qt/config.h" +#include "citra_qt/game_list.h" #include "citra_qt/hotkeys.h" #include "citra_qt/main.h" @@ -47,10 +48,6 @@ #include "video_core/video_core.h" -#ifdef USE_GDBSTUB -#include "core/gdbstub/gdbstub.h" -#endif - #include "core/gdbstub/gdbstub.h" GMainWindow::GMainWindow() : emu_thread(nullptr) @@ -65,6 +62,9 @@ GMainWindow::GMainWindow() : emu_thread(nullptr) render_window = new GRenderWindow(this, emu_thread.get()); render_window->hide(); + game_list = new GameList(); + ui.horizontalLayout->addWidget(game_list); + profilerWidget = new ProfilerWidget(this); addDockWidget(Qt::BottomDockWidgetArea, profilerWidget); profilerWidget->hide(); @@ -143,9 +143,7 @@ GMainWindow::GMainWindow() : emu_thread(nullptr) microProfileDialog->setVisible(settings.value("microProfileDialogVisible").toBool()); settings.endGroup(); -#ifdef USE_GDBSTUB - Gdbstub::SetServerPort(static_cast<u32>(Settings::values.gdbstub_port)); -#endif + game_list->LoadInterfaceLayout(settings); ui.action_Use_Gdbstub->setChecked(Settings::values.use_gdbstub); SetGdbstubEnabled(ui.action_Use_Gdbstub->isChecked()); @@ -175,8 +173,10 @@ GMainWindow::GMainWindow() : emu_thread(nullptr) UpdateRecentFiles(); // Setup connections + connect(game_list, SIGNAL(GameChosen(QString)), this, SLOT(OnGameListLoadFile(QString))); connect(ui.action_Load_File, SIGNAL(triggered()), this, SLOT(OnMenuLoadFile())); connect(ui.action_Load_Symbol_Map, SIGNAL(triggered()), this, SLOT(OnMenuLoadSymbolMap())); + connect(ui.action_Select_Game_List_Root, SIGNAL(triggered()), this, SLOT(OnMenuSelectGameListRoot())); connect(ui.action_Start, SIGNAL(triggered()), this, SLOT(OnStartGame())); connect(ui.action_Pause, SIGNAL(triggered()), this, SLOT(OnPauseGame())); connect(ui.action_Stop, SIGNAL(triggered()), this, SLOT(OnStopGame())); @@ -209,6 +209,8 @@ GMainWindow::GMainWindow() : emu_thread(nullptr) show(); + game_list->PopulateAsync(settings.value("gameListRootDir").toString(), settings.value("gameListDeepScan").toBool()); + QStringList args = QApplication::arguments(); if (args.length() >= 2) { BootGame(args[1].toStdString()); @@ -280,8 +282,12 @@ void GMainWindow::BootGame(const std::string& filename) { // Update the GUI registersWidget->OnDebugModeEntered(); callstackWidget->OnDebugModeEntered(); + if (ui.action_Single_Window_Mode->isChecked()) { + game_list->hide(); + } render_window->show(); + emulation_running = true; OnStartGame(); } @@ -310,6 +316,9 @@ void GMainWindow::ShutdownGame() { ui.action_Pause->setEnabled(false); ui.action_Stop->setEnabled(false); render_window->hide(); + game_list->show(); + + emulation_running = false; } void GMainWindow::StoreRecentFile(const QString& filename) @@ -353,12 +362,16 @@ void GMainWindow::UpdateRecentFiles() { } } +void GMainWindow::OnGameListLoadFile(QString game_path) { + BootGame(game_path.toLatin1().data()); +} + void GMainWindow::OnMenuLoadFile() { QSettings settings; QString rom_path = settings.value("romsPath", QString()).toString(); QString filename = QFileDialog::getOpenFileName(this, tr("Load File"), rom_path, tr("3DS executable (*.3ds *.3dsx *.elf *.axf *.cci *.cxi)")); - if (filename.size()) { + if (!filename.isEmpty()) { settings.setValue("romsPath", QFileInfo(filename).path()); StoreRecentFile(filename); @@ -371,13 +384,23 @@ void GMainWindow::OnMenuLoadSymbolMap() { QString symbol_path = settings.value("symbolsPath", QString()).toString(); QString filename = QFileDialog::getOpenFileName(this, tr("Load Symbol Map"), symbol_path, tr("Symbol map (*)")); - if (filename.size()) { + if (!filename.isEmpty()) { settings.setValue("symbolsPath", QFileInfo(filename).path()); LoadSymbolMap(filename.toLatin1().data()); } } +void GMainWindow::OnMenuSelectGameListRoot() { + QSettings settings; + + QString dir_path = QFileDialog::getExistingDirectory(this, tr("Select Directory")); + if (!dir_path.isEmpty()) { + settings.setValue("gameListRootDir", dir_path); + game_list->PopulateAsync(dir_path, settings.value("gameListDeepScan").toBool()); + } +} + void GMainWindow::OnMenuRecentFile() { QAction* action = qobject_cast<QAction*>(sender()); assert(action); @@ -443,17 +466,22 @@ void GMainWindow::ToggleWindowMode() { // Render in the main window... render_window->BackupGeometry(); ui.horizontalLayout->addWidget(render_window); - render_window->setVisible(true); render_window->setFocusPolicy(Qt::ClickFocus); - render_window->setFocus(); + if (emulation_running) { + render_window->setVisible(true); + render_window->setFocus(); + } } else { // Render in a separate window... ui.horizontalLayout->removeWidget(render_window); render_window->setParent(nullptr); - render_window->setVisible(true); - render_window->RestoreGeometry(); render_window->setFocusPolicy(Qt::NoFocus); + if (emulation_running) { + render_window->setVisible(true); + render_window->RestoreGeometry(); + game_list->show(); + } } } @@ -476,6 +504,7 @@ void GMainWindow::closeEvent(QCloseEvent* event) { settings.setValue("singleWindowMode", ui.action_Single_Window_Mode->isChecked()); settings.setValue("displayTitleBars", ui.actionDisplay_widget_title_bars->isChecked()); settings.setValue("firstStart", false); + game_list->SaveInterfaceLayout(settings); SaveHotkeys(settings); // Shutdown session if the emu thread is active... diff --git a/src/citra_qt/main.h b/src/citra_qt/main.h index daa3d1c95..f6d429cd9 100644 --- a/src/citra_qt/main.h +++ b/src/citra_qt/main.h @@ -10,6 +10,7 @@ #include "ui_main.h" +class GameList; class GImageInfo; class GRenderWindow; class EmuThread; @@ -87,8 +88,12 @@ private slots: void OnStartGame(); void OnPauseGame(); void OnStopGame(); + /// Called whenever a user selects a game in the game list widget. + void OnGameListLoadFile(QString game_path); void OnMenuLoadFile(); void OnMenuLoadSymbolMap(); + /// Called whenever a user selects the "File->Select Game List Root" menu item + void OnMenuSelectGameListRoot(); void OnMenuRecentFile(); void OnOpenHotkeysDialog(); void OnConfigure(); @@ -102,7 +107,10 @@ private: Ui::MainWindow ui; GRenderWindow* render_window; + GameList* game_list; + // Whether emulation is currently running in Citra. + bool emulation_running = false; std::unique_ptr<EmuThread> emu_thread; ProfilerWidget* profilerWidget; diff --git a/src/citra_qt/main.ui b/src/citra_qt/main.ui index 88d04439a..1e8a07cfb 100644 --- a/src/citra_qt/main.ui +++ b/src/citra_qt/main.ui @@ -45,7 +45,7 @@ <x>0</x> <y>0</y> <width>1081</width> - <height>21</height> + <height>22</height> </rect> </property> <widget class="QMenu" name="menu_File"> @@ -60,6 +60,7 @@ <addaction name="action_Load_File"/> <addaction name="action_Load_Symbol_Map"/> <addaction name="separator"/> + <addaction name="action_Select_Game_List_Root"/> <addaction name="menu_recent_files"/> <addaction name="separator"/> <addaction name="action_Exit"/> @@ -191,6 +192,14 @@ <string>Display Dock Widget Headers</string> </property> </action> + <action name="action_Select_Game_List_Root"> + <property name="text"> + <string>Select Game Directory...</string> + </property> + <property name="toolTip"> + <string>Selects a folder to display in the game list</string> + </property> + </action> </widget> <resources/> <connections> diff --git a/src/citra_qt/util/util.cpp b/src/citra_qt/util/util.cpp index f292046b7..8734a8efd 100644 --- a/src/citra_qt/util/util.cpp +++ b/src/citra_qt/util/util.cpp @@ -2,6 +2,9 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. +#include <array> +#include <cmath> + #include "citra_qt/util/util.h" QFont GetMonospaceFont() { @@ -11,3 +14,12 @@ QFont GetMonospaceFont() { font.setFixedPitch(true); return font; } + +QString ReadableByteSize(qulonglong size) { + static const std::array<const char*, 6> units = { "B", "KiB", "MiB", "GiB", "TiB", "PiB" }; + if (size == 0) + return "0"; + int digit_groups = std::min<int>((int)(std::log10(size) / std::log10(1024)), units.size()); + return QString("%L1 %2").arg(size / std::pow(1024, digit_groups), 0, 'f', 1) + .arg(units[digit_groups]); +} diff --git a/src/citra_qt/util/util.h b/src/citra_qt/util/util.h index 98a944047..ab443ef9b 100644 --- a/src/citra_qt/util/util.h +++ b/src/citra_qt/util/util.h @@ -5,6 +5,10 @@ #pragma once #include <QFont> +#include <QString> /// Returns a QFont object appropriate to use as a monospace font for debugging widgets, etc. QFont GetMonospaceFont(); + +/// Convert a size in bytes into a readable format (KiB, MiB, etc.) +QString ReadableByteSize(qulonglong size); diff --git a/src/common/bit_field.h b/src/common/bit_field.h index d306ce9a9..66689f398 100644 --- a/src/common/bit_field.h +++ b/src/common/bit_field.h @@ -125,21 +125,10 @@ public: // so that we can use this within unions BitField() = default; -#ifndef _WIN32 // We explicitly delete the copy assigment operator here, because the // default copy assignment would copy the full storage value, rather than // just the bits relevant to this particular bit field. - // Ideally, we would just implement the copy assignment to copy only the - // relevant bits, but this requires compiler support for unrestricted - // unions. - // MSVC 2013 has no support for this, hence we disable this code on - // Windows (so that the default copy assignment operator will be used). - // For any C++11 conformant compiler we delete the operator to make sure - // we never use this inappropriate operator to begin with. - // TODO: Implement this operator properly once all target compilers - // support unrestricted unions. BitField& operator=(const BitField&) = delete; -#endif FORCE_INLINE BitField& operator=(T val) { diff --git a/src/common/file_util.cpp b/src/common/file_util.cpp index 836b58d52..1e0d33313 100644 --- a/src/common/file_util.cpp +++ b/src/common/file_util.cpp @@ -420,28 +420,23 @@ bool CreateEmptyFile(const std::string &filename) } -// Scans the directory tree gets, starting from _Directory and adds the -// results into parentEntry. Returns the number of files+directories found -u32 ScanDirectoryTree(const std::string &directory, FSTEntry& parentEntry) +int ScanDirectoryTreeAndCallback(const std::string &directory, std::function<int(const std::string&, const std::string&)> callback) { LOG_TRACE(Common_Filesystem, "directory %s", directory.c_str()); // How many files + directories we found - u32 foundEntries = 0; + int found_entries = 0; #ifdef _WIN32 // Find the first file in the directory. WIN32_FIND_DATA ffd; - HANDLE hFind = FindFirstFile(Common::UTF8ToTStr(directory + "\\*").c_str(), &ffd); - if (hFind == INVALID_HANDLE_VALUE) - { - FindClose(hFind); - return foundEntries; + HANDLE handle_find = FindFirstFile(Common::UTF8ToTStr(directory + "\\*").c_str(), &ffd); + if (handle_find == INVALID_HANDLE_VALUE) { + FindClose(handle_find); + return found_entries; } // windows loop - do - { - FSTEntry entry; - const std::string virtualName(Common::TStrToUTF8(ffd.cFileName)); + do { + const std::string virtual_name(Common::TStrToUTF8(ffd.cFileName)); #else struct dirent dirent, *result = nullptr; @@ -450,115 +445,80 @@ u32 ScanDirectoryTree(const std::string &directory, FSTEntry& parentEntry) return 0; // non windows loop - while (!readdir_r(dirp, &dirent, &result) && result) - { - FSTEntry entry; - const std::string virtualName(result->d_name); + while (!readdir_r(dirp, &dirent, &result) && result) { + const std::string virtual_name(result->d_name); #endif // check for "." and ".." - if (((virtualName[0] == '.') && (virtualName[1] == '\0')) || - ((virtualName[0] == '.') && (virtualName[1] == '.') && - (virtualName[2] == '\0'))) + if (((virtual_name[0] == '.') && (virtual_name[1] == '\0')) || + ((virtual_name[0] == '.') && (virtual_name[1] == '.') && + (virtual_name[2] == '\0'))) continue; - entry.virtualName = virtualName; - entry.physicalName = directory; - entry.physicalName += DIR_SEP + entry.virtualName; - if (IsDirectory(entry.physicalName.c_str())) - { - entry.isDirectory = true; - // is a directory, lets go inside - entry.size = ScanDirectoryTree(entry.physicalName, entry); - foundEntries += (u32)entry.size; - } - else - { // is a file - entry.isDirectory = false; - entry.size = GetSize(entry.physicalName.c_str()); + int ret = callback(directory, virtual_name); + if (ret < 0) { + if (ret != -1) + found_entries = ret; + break; } - ++foundEntries; - // Push into the tree - parentEntry.children.push_back(entry); + found_entries += ret; + #ifdef _WIN32 - } while (FindNextFile(hFind, &ffd) != 0); - FindClose(hFind); + } while (FindNextFile(handle_find, &ffd) != 0); + FindClose(handle_find); #else } closedir(dirp); #endif // Return number of entries found. - return foundEntries; + return found_entries; } - -// Deletes the given directory and anything under it. Returns true on success. -bool DeleteDirRecursively(const std::string &directory) +int ScanDirectoryTree(const std::string &directory, FSTEntry& parent_entry) { - LOG_TRACE(Common_Filesystem, "%s", directory.c_str()); -#ifdef _WIN32 - // Find the first file in the directory. - WIN32_FIND_DATA ffd; - HANDLE hFind = FindFirstFile(Common::UTF8ToTStr(directory + "\\*").c_str(), &ffd); - - if (hFind == INVALID_HANDLE_VALUE) - { - FindClose(hFind); - return false; - } - - // windows loop - do - { - const std::string virtualName(Common::TStrToUTF8(ffd.cFileName)); -#else - struct dirent dirent, *result = nullptr; - DIR *dirp = opendir(directory.c_str()); - if (!dirp) - return false; - - // non windows loop - while (!readdir_r(dirp, &dirent, &result) && result) - { - const std::string virtualName = result->d_name; -#endif + const auto callback = [&parent_entry](const std::string& directory, + const std::string& virtual_name) -> int { + FSTEntry entry; + int found_entries = 0; + entry.virtualName = virtual_name; + entry.physicalName = directory + DIR_SEP + virtual_name; - // check for "." and ".." - if (((virtualName[0] == '.') && (virtualName[1] == '\0')) || - ((virtualName[0] == '.') && (virtualName[1] == '.') && - (virtualName[2] == '\0'))) - continue; + if (IsDirectory(entry.physicalName)) { + entry.isDirectory = true; + // is a directory, lets go inside + entry.size = ScanDirectoryTree(entry.physicalName, entry); + found_entries += (int)entry.size; + } else { // is a file + entry.isDirectory = false; + entry.size = GetSize(entry.physicalName); + } + ++found_entries; + // Push into the tree + parent_entry.children.push_back(entry); + return found_entries; + }; - std::string newPath = directory + DIR_SEP_CHR + virtualName; - if (IsDirectory(newPath)) - { - if (!DeleteDirRecursively(newPath)) - { - #ifndef _WIN32 - closedir(dirp); - #endif + return ScanDirectoryTreeAndCallback(directory, callback); +} - return false; - } - } - else - { - if (!FileUtil::Delete(newPath)) - { - #ifndef _WIN32 - closedir(dirp); - #endif - return false; +bool DeleteDirRecursively(const std::string &directory) +{ + const static auto callback = [](const std::string& directory, + const std::string& virtual_name) -> int { + std::string new_path = directory + DIR_SEP_CHR + virtual_name; + if (IsDirectory(new_path)) { + if (!DeleteDirRecursively(new_path)) { + return -2; } + } else if (!Delete(new_path)) { + return -2; } + return 0; + }; -#ifdef _WIN32 - } while (FindNextFile(hFind, &ffd) != 0); - FindClose(hFind); -#else + if (ScanDirectoryTreeAndCallback(directory, callback) == -2) { + return false; } - closedir(dirp); -#endif FileUtil::DeleteDir(directory); return true; @@ -861,8 +821,8 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam const std::string forbidden_characters = ".\"/\\[]:;=, "; // On a FAT32 partition, 8.3 names are stored as a 11 bytes array, filled with spaces. - short_name = {' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\0'}; - extension = {' ', ' ', ' ', '\0'}; + short_name = {{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\0'}}; + extension = {{' ', ' ', ' ', '\0'}}; std::string::size_type point = filename.rfind('.'); if (point == filename.size() - 1) diff --git a/src/common/file_util.h b/src/common/file_util.h index e71a9b2fa..3d617f573 100644 --- a/src/common/file_util.h +++ b/src/common/file_util.h @@ -6,6 +6,7 @@ #include <array> #include <fstream> +#include <functional> #include <cstddef> #include <cstdio> #include <string> @@ -96,9 +97,28 @@ bool Copy(const std::string &srcFilename, const std::string &destFilename); // creates an empty file filename, returns true on success bool CreateEmptyFile(const std::string &filename); -// Scans the directory tree gets, starting from _Directory and adds the -// results into parentEntry. Returns the number of files+directories found -u32 ScanDirectoryTree(const std::string &directory, FSTEntry& parentEntry); +/** + * Scans the directory tree, calling the callback for each file/directory found. + * The callback must return the number of files and directories which the provided path contains. + * If the callback's return value is -1, the callback loop is broken immediately. + * If the callback's return value is otherwise negative, the callback loop is broken immediately + * and the callback's return value is returned from this function (to allow for error handling). + * @param directory the parent directory to start scanning from + * @param callback The callback which will be called for each file/directory. It is called + * with the arguments (const std::string& directory, const std::string& virtual_name). + * The `directory `parameter is the path to the directory which contains the file/directory. + * The `virtual_name` parameter is the incomplete file path, without any directory info. + * @return the total number of files/directories found + */ +int ScanDirectoryTreeAndCallback(const std::string &directory, std::function<int(const std::string&, const std::string&)> callback); + +/** + * Scans the directory tree, storing the results. + * @param directory the parent directory to start scanning from + * @param parent_entry FSTEntry where the filesystem tree results will be stored. + * @return the total number of files/directories found + */ +int ScanDirectoryTree(const std::string &directory, FSTEntry& parent_entry); // deletes the given directory and anything under it. Returns true on success. bool DeleteDirRecursively(const std::string &directory); diff --git a/src/common/hash.cpp b/src/common/hash.cpp index 413e9c6f1..c49c2f60e 100644 --- a/src/common/hash.cpp +++ b/src/common/hash.cpp @@ -17,27 +17,11 @@ namespace Common { // Block read - if your platform needs to do endian-swapping or can only handle aligned reads, do // the conversion here - -static FORCE_INLINE u32 getblock32(const u32* p, int i) { - return p[i]; -} - static FORCE_INLINE u64 getblock64(const u64* p, int i) { return p[i]; } // Finalization mix - force all bits of a hash block to avalanche - -static FORCE_INLINE u32 fmix32(u32 h) { - h ^= h >> 16; - h *= 0x85ebca6b; - h ^= h >> 13; - h *= 0xc2b2ae35; - h ^= h >> 16; - - return h; -} - static FORCE_INLINE u64 fmix64(u64 k) { k ^= k >> 33; k *= 0xff51afd7ed558ccdllu; diff --git a/src/common/symbols.cpp b/src/common/symbols.cpp index f23e51c9d..db8340043 100644 --- a/src/common/symbols.cpp +++ b/src/common/symbols.cpp @@ -8,46 +8,43 @@ TSymbolsMap g_symbols; namespace Symbols { - bool HasSymbol(u32 _address) + bool HasSymbol(u32 address) { - return g_symbols.find(_address) != g_symbols.end(); + return g_symbols.find(address) != g_symbols.end(); } - void Add(u32 _address, const std::string& _name, u32 _size, u32 _type) + void Add(u32 address, const std::string& name, u32 size, u32 type) { - if (!HasSymbol(_address)) + if (!HasSymbol(address)) { TSymbol symbol; - symbol.address = _address; - symbol.name = _name; - symbol.size = _size; - symbol.type = _type; + symbol.address = address; + symbol.name = name; + symbol.size = size; + symbol.type = type; - g_symbols.insert(TSymbolsPair(_address, symbol)); + g_symbols.emplace(address, symbol); } } - TSymbol GetSymbol(u32 _address) + TSymbol GetSymbol(u32 address) { - TSymbolsMap::iterator foundSymbolItr; - TSymbol symbol; + const auto iter = g_symbols.find(address); - foundSymbolItr = g_symbols.find(_address); - if (foundSymbolItr != g_symbols.end()) - { - symbol = (*foundSymbolItr).second; - } + if (iter != g_symbols.end()) + return iter->second; - return symbol; + return {}; } - const std::string GetName(u32 _address) + + const std::string GetName(u32 address) { - return GetSymbol(_address).name; + return GetSymbol(address).name; } - void Remove(u32 _address) + void Remove(u32 address) { - g_symbols.erase(_address); + g_symbols.erase(address); } void Clear() diff --git a/src/common/symbols.h b/src/common/symbols.h index 6b62b011e..5ed16009c 100644 --- a/src/common/symbols.h +++ b/src/common/symbols.h @@ -12,15 +12,10 @@ struct TSymbol { - TSymbol() : - address(0), - size(0), - type(0) - {} - u32 address; + u32 address = 0; std::string name; - u32 size; - u32 type; + u32 size = 0; + u32 type = 0; }; typedef std::map<u32, TSymbol> TSymbolsMap; @@ -28,12 +23,12 @@ typedef std::pair<u32, TSymbol> TSymbolsPair; namespace Symbols { - bool HasSymbol(u32 _address); + bool HasSymbol(u32 address); - void Add(u32 _address, const std::string& _name, u32 _size, u32 _type); - TSymbol GetSymbol(u32 _address); - const std::string GetName(u32 _address); - void Remove(u32 _address); + void Add(u32 address, const std::string& name, u32 size, u32 type); + TSymbol GetSymbol(u32 address); + const std::string GetName(u32 address); + void Remove(u32 address); void Clear(); } diff --git a/src/core/arm/skyeye_common/armstate.h b/src/core/arm/skyeye_common/armstate.h index c0536c02f..98dad9b1f 100644 --- a/src/core/arm/skyeye_common/armstate.h +++ b/src/core/arm/skyeye_common/armstate.h @@ -249,6 +249,5 @@ private: static const u32 RESERVATION_GRANULE_MASK = 0xFFFFFFF8; u32 exclusive_tag; // The address for which the local monitor is in exclusive access mode - u32 exclusive_result; bool exclusive_state; }; diff --git a/src/core/core_timing.cpp b/src/core/core_timing.cpp index 56615502c..aba22cdd1 100644 --- a/src/core/core_timing.cpp +++ b/src/core/core_timing.cpp @@ -3,6 +3,7 @@ // Refer to the license.txt file included. #include <atomic> +#include <cinttypes> #include <mutex> #include <vector> @@ -530,7 +531,7 @@ void Idle(int max_idle) { } } - LOG_TRACE(Core_Timing, "Idle for %i cycles! (%f ms)", cycles_down, cycles_down / (float)(g_clock_rate_arm11 * 0.001f)); + LOG_TRACE(Core_Timing, "Idle for %" PRId64 " cycles! (%f ms)", cycles_down, cycles_down / (float)(g_clock_rate_arm11 * 0.001f)); idled_cycles += cycles_down; Core::g_app_core->down_count -= cycles_down; diff --git a/src/core/file_sys/ivfc_archive.cpp b/src/core/file_sys/ivfc_archive.cpp index e16aa1491..441ca9b53 100644 --- a/src/core/file_sys/ivfc_archive.cpp +++ b/src/core/file_sys/ivfc_archive.cpp @@ -62,7 +62,7 @@ std::unique_ptr<DirectoryBackend> IVFCArchive::OpenDirectory(const Path& path) c //////////////////////////////////////////////////////////////////////////////////////////////////// size_t IVFCFile::Read(const u64 offset, const size_t length, u8* buffer) const { - LOG_TRACE(Service_FS, "called offset=%llu, length=%d", offset, length); + LOG_TRACE(Service_FS, "called offset=%llu, length=%zu", offset, length); romfs_file->Seek(data_offset + offset, SEEK_SET); size_t read_length = (size_t)std::min((u64)length, data_size - offset); diff --git a/src/core/hle/kernel/timer.cpp b/src/core/hle/kernel/timer.cpp index 8aa4110a6..08b3ea8c0 100644 --- a/src/core/hle/kernel/timer.cpp +++ b/src/core/hle/kernel/timer.cpp @@ -2,6 +2,8 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. +#include <cinttypes> + #include "common/assert.h" #include "common/logging/log.h" @@ -71,11 +73,11 @@ static void TimerCallback(u64 timer_handle, int cycles_late) { SharedPtr<Timer> timer = timer_callback_handle_table.Get<Timer>(static_cast<Handle>(timer_handle)); if (timer == nullptr) { - LOG_CRITICAL(Kernel, "Callback fired for invalid timer %08lX", timer_handle); + LOG_CRITICAL(Kernel, "Callback fired for invalid timer %08" PRIx64, timer_handle); return; } - LOG_TRACE(Kernel, "Timer %u fired", timer_handle); + LOG_TRACE(Kernel, "Timer %08" PRIx64 " fired", timer_handle); timer->signaled = true; diff --git a/src/core/hle/service/cfg/cfg.cpp b/src/core/hle/service/cfg/cfg.cpp index 6f2cf0190..56986a49e 100644 --- a/src/core/hle/service/cfg/cfg.cpp +++ b/src/core/hle/service/cfg/cfg.cpp @@ -77,10 +77,10 @@ static const ConsoleCountryInfo COUNTRY_INFO = { { 0, 0, 0 }, UNITED_STATES_COUN * for example Nintendo Zone * Thanks Normmatt for providing this information */ -static const std::array<float, 8> STEREO_CAMERA_SETTINGS = { +static const std::array<float, 8> STEREO_CAMERA_SETTINGS = {{ 62.0f, 289.0f, 76.80000305175781f, 46.08000183105469f, 10.0f, 5.0f, 55.58000183105469f, 21.56999969482422f -}; +}}; static_assert(sizeof(STEREO_CAMERA_SETTINGS) == 0x20, "STEREO_CAMERA_SETTINGS must be exactly 0x20 bytes"); static const u32 CONFIG_SAVEFILE_SIZE = 0x8000; @@ -345,7 +345,7 @@ ResultCode FormatConfig() { char16_t country_name_buffer[16][0x40] = {}; for (size_t i = 0; i < 16; ++i) { - auto size = Common::UTF8ToUTF16("Gensokyo").copy(country_name_buffer[i], 0x40); + Common::UTF8ToUTF16("Gensokyo").copy(country_name_buffer[i], 0x40); } // 0x000B0001 - Localized names for the profile Country res = CreateConfigInfoBlk(0x000B0001, sizeof(country_name_buffer), 0xE, country_name_buffer); diff --git a/src/core/hle/service/cfg/cfg.h b/src/core/hle/service/cfg/cfg.h index 7b7a76b08..fc2a16a04 100644 --- a/src/core/hle/service/cfg/cfg.h +++ b/src/core/hle/service/cfg/cfg.h @@ -41,10 +41,11 @@ struct SaveConfigBlockEntry { u16 flags; ///< The flags of the block, possibly used for access control }; -// TODO(Link Mauve): use a constexpr once MSVC starts supporting it. -#define C(code) (u16)((code)[0] | ((code)[1] << 8)) +static constexpr u16 C(const char code[2]) { + return code[0] | (code[1] << 8); +} -static const std::array<u16, 187> country_codes = { +static const std::array<u16, 187> country_codes = {{ 0, C("JP"), 0, 0, 0, 0, 0, 0, // 0-7 C("AI"), C("AG"), C("AR"), C("AW"), C("BS"), C("BB"), C("BZ"), C("BO"), // 8-15 C("BR"), C("VG"), C("CA"), C("KY"), C("CL"), C("CO"), C("CR"), C("DM"), // 16-23 @@ -69,9 +70,7 @@ static const std::array<u16, 187> country_codes = { C("AE"), C("IN"), C("EG"), C("OM"), C("QA"), C("KW"), C("SA"), C("SY"), // 168-175 C("BH"), C("JO"), 0, 0, 0, 0, 0, 0, // 176-183 C("SM"), C("VA"), C("BM") // 184-186 -}; - -#undef C +}}; /** * CFG::GetCountryCodeString service function diff --git a/src/core/hle/service/dsp_dsp.cpp b/src/core/hle/service/dsp_dsp.cpp index a8cb15d60..ce5619069 100644 --- a/src/core/hle/service/dsp_dsp.cpp +++ b/src/core/hle/service/dsp_dsp.cpp @@ -212,10 +212,10 @@ static void ReadPipeIfPossible(Service::Interface* self) { // Canned DSP responses that games expect. These were taken from HW by 3dmoo team. // TODO: Remove this hack :) - static const std::array<u16, 16> canned_read_pipe = { + static const std::array<u16, 16> canned_read_pipe = {{ 0x000F, 0xBFFF, 0x9E8E, 0x8680, 0xA78E, 0x9430, 0x8400, 0x8540, 0x948E, 0x8710, 0x8410, 0xA90E, 0xAA0E, 0xAACE, 0xAC4E, 0xAC58 - }; + }}; u32 initial_size = read_pipe_count; diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp index c35b13b25..2e1e5c3e9 100644 --- a/src/core/hle/service/hid/hid.cpp +++ b/src/core/hle/service/hid/hid.cpp @@ -35,14 +35,14 @@ static Kernel::SharedPtr<Kernel::Event> event_debug_pad; static u32 next_pad_index; static u32 next_touch_index; -const std::array<Service::HID::PadState, Settings::NativeInput::NUM_INPUTS> pad_mapping = { +const std::array<Service::HID::PadState, Settings::NativeInput::NUM_INPUTS> pad_mapping = {{ Service::HID::PAD_A, Service::HID::PAD_B, Service::HID::PAD_X, Service::HID::PAD_Y, Service::HID::PAD_L, Service::HID::PAD_R, Service::HID::PAD_ZL, Service::HID::PAD_ZR, Service::HID::PAD_START, Service::HID::PAD_SELECT, Service::HID::PAD_NONE, Service::HID::PAD_UP, Service::HID::PAD_DOWN, Service::HID::PAD_LEFT, Service::HID::PAD_RIGHT, Service::HID::PAD_CIRCLE_UP, Service::HID::PAD_CIRCLE_DOWN, Service::HID::PAD_CIRCLE_LEFT, Service::HID::PAD_CIRCLE_RIGHT, Service::HID::PAD_C_UP, Service::HID::PAD_C_DOWN, Service::HID::PAD_C_LEFT, Service::HID::PAD_C_RIGHT -}; +}}; // TODO(peachum): diff --git a/src/core/loader/3dsx.cpp b/src/core/loader/3dsx.cpp index 530837d08..111b6a409 100644 --- a/src/core/loader/3dsx.cpp +++ b/src/core/loader/3dsx.cpp @@ -62,6 +62,10 @@ struct THREEDSX_Header // Sizes of the code, rodata and data segments + // size of the BSS section (uninitialized latter half of the data segment) u32 code_seg_size, rodata_seg_size, data_seg_size, bss_size; + // offset and size of smdh + u32 smdh_offset, smdh_size; + // offset to filesystem + u32 fs_offset; }; // Relocation header: all fields (even extra unknown fields) are guaranteed to be relocation counts. @@ -267,4 +271,40 @@ ResultStatus AppLoader_THREEDSX::Load() { return ResultStatus::Success; } +ResultStatus AppLoader_THREEDSX::ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset, u64& size) { + if (!file.IsOpen()) + return ResultStatus::Error; + + // Reset read pointer in case this file has been read before. + file.Seek(0, SEEK_SET); + + THREEDSX_Header hdr; + if (file.ReadBytes(&hdr, sizeof(THREEDSX_Header)) != sizeof(THREEDSX_Header)) + return ResultStatus::Error; + + if (hdr.header_size != sizeof(THREEDSX_Header)) + return ResultStatus::Error; + + // Check if the 3DSX has a RomFS... + if (hdr.fs_offset != 0) { + u32 romfs_offset = hdr.fs_offset; + u32 romfs_size = file.GetSize() - hdr.fs_offset; + + LOG_DEBUG(Loader, "RomFS offset: 0x%08X", romfs_offset); + LOG_DEBUG(Loader, "RomFS size: 0x%08X", romfs_size); + + // We reopen the file, to allow its position to be independent from file's + romfs_file = std::make_shared<FileUtil::IOFile>(filepath, "rb"); + if (!romfs_file->IsOpen()) + return ResultStatus::Error; + + offset = romfs_offset; + size = romfs_size; + + return ResultStatus::Success; + } + LOG_DEBUG(Loader, "3DSX has no RomFS"); + return ResultStatus::ErrorNotUsed; +} + } // namespace Loader diff --git a/src/core/loader/3dsx.h b/src/core/loader/3dsx.h index a0aa0c533..365ddb7a5 100644 --- a/src/core/loader/3dsx.h +++ b/src/core/loader/3dsx.h @@ -17,8 +17,8 @@ namespace Loader { /// Loads an 3DSX file class AppLoader_THREEDSX final : public AppLoader { public: - AppLoader_THREEDSX(FileUtil::IOFile&& file, std::string filename) - : AppLoader(std::move(file)), filename(std::move(filename)) {} + AppLoader_THREEDSX(FileUtil::IOFile&& file, std::string filename, const std::string& filepath) + : AppLoader(std::move(file)), filename(std::move(filename)), filepath(filepath) {} /** * Returns the type of the file @@ -33,8 +33,18 @@ public: */ ResultStatus Load() override; + /** + * Get the RomFS of the application + * @param romfs_file Reference to buffer to store data + * @param offset Offset in the file to the RomFS + * @param size Size of the RomFS in bytes + * @return ResultStatus result of function + */ + ResultStatus ReadRomFS(std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset, u64& size) override; + private: std::string filename; + std::string filepath; }; } // namespace Loader diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp index 74eb6e871..6b88169e1 100644 --- a/src/core/loader/loader.cpp +++ b/src/core/loader/loader.cpp @@ -26,12 +26,7 @@ const std::initializer_list<Kernel::AddressMapping> default_address_mappings = { { 0x1F000000, 0x600000, false }, // entire VRAM }; -/** - * Identifies the type of a bootable file - * @param file open file - * @return FileType of file - */ -static FileType IdentifyFile(FileUtil::IOFile& file) { +FileType IdentifyFile(FileUtil::IOFile& file) { FileType type; #define CHECK_TYPE(loader) \ @@ -48,12 +43,17 @@ static FileType IdentifyFile(FileUtil::IOFile& file) { return FileType::Unknown; } -/** - * Guess the type of a bootable file from its extension - * @param extension_ String extension of bootable file - * @return FileType of file - */ -static FileType GuessFromExtension(const std::string& extension_) { +FileType IdentifyFile(const std::string& file_name) { + FileUtil::IOFile file(file_name, "rb"); + if (!file.IsOpen()) { + LOG_ERROR(Loader, "Failed to load file %s", file_name.c_str()); + return FileType::Unknown; + } + + return IdentifyFile(file); +} + +FileType GuessFromExtension(const std::string& extension_) { std::string extension = Common::ToLower(extension_); if (extension == ".elf" || extension == ".axf") @@ -71,7 +71,7 @@ static FileType GuessFromExtension(const std::string& extension_) { return FileType::Unknown; } -static const char* GetFileTypeString(FileType type) { +const char* GetFileTypeString(FileType type) { switch (type) { case FileType::CCI: return "NCSD"; @@ -116,7 +116,15 @@ ResultStatus LoadFile(const std::string& filename) { //3DSX file format... case FileType::THREEDSX: - return AppLoader_THREEDSX(std::move(file), filename_filename).Load(); + { + AppLoader_THREEDSX app_loader(std::move(file), filename_filename, filename); + // Load application and RomFS + if (ResultStatus::Success == app_loader.Load()) { + Service::FS::RegisterArchiveType(Common::make_unique<FileSys::ArchiveFactory_RomFS>(app_loader), Service::FS::ArchiveIdCode::RomFS); + return ResultStatus::Success; + } + break; + } // Standard ELF file format... case FileType::ELF: diff --git a/src/core/loader/loader.h b/src/core/loader/loader.h index a37d3348c..8de95dacf 100644 --- a/src/core/loader/loader.h +++ b/src/core/loader/loader.h @@ -33,6 +33,34 @@ enum class FileType { THREEDSX, //3DSX }; +/** + * Identifies the type of a bootable file based on the magic value in its header. + * @param file open file + * @return FileType of file + */ +FileType IdentifyFile(FileUtil::IOFile& file); + +/** + * Identifies the type of a bootable file based on the magic value in its header. + * @param file_name path to file + * @return FileType of file. Note: this will return FileType::Unknown if it is unable to determine + * a filetype, and will never return FileType::Error. + */ +FileType IdentifyFile(const std::string& file_name); + +/** + * Guess the type of a bootable file from its extension + * @param extension String extension of bootable file + * @return FileType of file. Note: this will return FileType::Unknown if it is unable to determine + * a filetype, and will never return FileType::Error. + */ +FileType GuessFromExtension(const std::string& extension_); + +/** + * Convert a FileType into a string which can be displayed to the user. + */ +const char* GetFileTypeString(FileType type); + /// Return type for functions in Loader namespace enum class ResultStatus { Success, diff --git a/src/core/settings.h b/src/core/settings.h index b6b395a79..97ddcdff9 100644 --- a/src/core/settings.h +++ b/src/core/settings.h @@ -20,22 +20,22 @@ enum Values { CUP, CDOWN, CLEFT, CRIGHT, NUM_INPUTS }; -static const std::array<const char*, NUM_INPUTS> Mapping = { +static const std::array<const char*, NUM_INPUTS> Mapping = {{ "pad_a", "pad_b", "pad_x", "pad_y", "pad_l", "pad_r", "pad_zl", "pad_zr", "pad_start", "pad_select", "pad_home", "pad_dup", "pad_ddown", "pad_dleft", "pad_dright", "pad_sup", "pad_sdown", "pad_sleft", "pad_sright", "pad_cup", "pad_cdown", "pad_cleft", "pad_cright" -}; -static const std::array<Values, NUM_INPUTS> All = { +}}; +static const std::array<Values, NUM_INPUTS> All = {{ A, B, X, Y, L, R, ZL, ZR, START, SELECT, HOME, DUP, DDOWN, DLEFT, DRIGHT, SUP, SDOWN, SLEFT, SRIGHT, CUP, CDOWN, CLEFT, CRIGHT -}; +}}; } diff --git a/src/core/tracer/recorder.cpp b/src/core/tracer/recorder.cpp index 656706c0c..c6dc35c83 100644 --- a/src/core/tracer/recorder.cpp +++ b/src/core/tracer/recorder.cpp @@ -143,11 +143,11 @@ void Recorder::Finish(const std::string& filename) { } void Recorder::FrameFinished() { - stream.push_back( { FrameMarker } ); + stream.push_back( { { FrameMarker } } ); } void Recorder::MemoryAccessed(const u8* data, u32 size, u32 physical_address) { - StreamElement element = { MemoryLoad }; + StreamElement element = { { MemoryLoad } }; element.data.memory_load.size = size; element.data.memory_load.physical_address = physical_address; @@ -168,7 +168,7 @@ void Recorder::MemoryAccessed(const u8* data, u32 size, u32 physical_address) { template<typename T> void Recorder::RegisterWritten(u32 physical_address, T value) { - StreamElement element = { RegisterWrite }; + StreamElement element = { { RegisterWrite } }; element.data.register_write.size = (sizeof(T) == 1) ? CTRegisterWrite::SIZE_8 : (sizeof(T) == 2) ? CTRegisterWrite::SIZE_16 : (sizeof(T) == 4) ? CTRegisterWrite::SIZE_32 diff --git a/src/video_core/debug_utils/debug_utils.cpp b/src/video_core/debug_utils/debug_utils.cpp index 77a4fe272..aa1f1484c 100644 --- a/src/video_core/debug_utils/debug_utils.cpp +++ b/src/video_core/debug_utils/debug_utils.cpp @@ -92,7 +92,7 @@ void GeometryDumper::AddTriangle(Vertex& v0, Vertex& v1, Vertex& v2) { vertices.push_back(v2); int num_vertices = (int)vertices.size(); - faces.push_back({ num_vertices-3, num_vertices-2, num_vertices-1 }); + faces.push_back({{ num_vertices-3, num_vertices-2, num_vertices-1 }}); } void GeometryDumper::Dump() { @@ -576,8 +576,8 @@ const Math::Vec4<u8> LookupTexture(const u8* source, int x, int y, const Texture unsigned table_index = static_cast<int>((x < 2) ? table_index_1.Value() : table_index_2.Value()); static const std::array<std::array<u8, 2>, 8> etc1_modifier_table = {{ - { 2, 8 }, { 5, 17 }, { 9, 29 }, { 13, 42 }, - { 18, 60 }, { 24, 80 }, { 33, 106 }, { 47, 183 } + {{ 2, 8 }}, {{ 5, 17 }}, {{ 9, 29 }}, {{ 13, 42 }}, + {{ 18, 60 }}, {{ 24, 80 }}, {{ 33, 106 }}, {{ 47, 183 }} }}; int modifier = etc1_modifier_table.at(table_index).at(GetTableSubIndex(texel)); diff --git a/src/video_core/gpu_debugger.h b/src/video_core/gpu_debugger.h index fae5de7d1..a3aab216c 100644 --- a/src/video_core/gpu_debugger.h +++ b/src/video_core/gpu_debugger.h @@ -45,7 +45,6 @@ public: private: GraphicsDebugger* observed; - bool in_destruction; friend class GraphicsDebugger; }; diff --git a/src/video_core/rasterizer.cpp b/src/video_core/rasterizer.cpp index a90ff5fef..7abf60292 100644 --- a/src/video_core/rasterizer.cpp +++ b/src/video_core/rasterizer.cpp @@ -735,11 +735,11 @@ static void ProcessTriangleInternal(const Shader::OutputVertex& v0, auto color_output = ColorCombine(tev_stage.color_op, color_result); // alpha combiner - std::array<u8,3> alpha_result = { + std::array<u8,3> alpha_result = {{ GetAlphaModifier(tev_stage.alpha_modifier1, GetSource(tev_stage.alpha_source1)), GetAlphaModifier(tev_stage.alpha_modifier2, GetSource(tev_stage.alpha_source2)), GetAlphaModifier(tev_stage.alpha_modifier3, GetSource(tev_stage.alpha_source3)) - }; + }}; auto alpha_output = AlphaCombine(tev_stage.alpha_op, alpha_result); combiner_output[0] = std::min((unsigned)255, color_output.r() * tev_stage.GetColorMultiplier()); @@ -967,6 +967,8 @@ static void ProcessTriangleInternal(const Shader::OutputVertex& v0, UNIMPLEMENTED(); break; } + + return {}; }; auto LookupFactorA = [&](Regs::BlendFactor factor) -> u8 { @@ -1000,6 +1002,8 @@ static void ProcessTriangleInternal(const Shader::OutputVertex& v0, UNIMPLEMENTED(); break; } + + return {}; }; static auto EvaluateBlendEquation = [](const Math::Vec4<u8>& src, const Math::Vec4<u8>& srcfactor, diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp index 22f261c68..f1313b54f 100644 --- a/src/video_core/renderer_opengl/renderer_opengl.cpp +++ b/src/video_core/renderer_opengl/renderer_opengl.cpp @@ -314,12 +314,12 @@ void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture, * Draws a single texture to the emulator window, rotating the texture to correct for the 3DS's LCD rotation. */ void RendererOpenGL::DrawSingleScreenRotated(const TextureInfo& texture, float x, float y, float w, float h) { - std::array<ScreenRectVertex, 4> vertices = { + std::array<ScreenRectVertex, 4> vertices = {{ ScreenRectVertex(x, y, 1.f, 0.f), ScreenRectVertex(x+w, y, 1.f, 1.f), ScreenRectVertex(x, y+h, 0.f, 0.f), ScreenRectVertex(x+w, y+h, 0.f, 1.f), - }; + }}; state.texture_units[0].texture_2d = texture.handle; state.Apply(); diff --git a/src/video_core/renderer_opengl/renderer_opengl.h b/src/video_core/renderer_opengl/renderer_opengl.h index 5677e538b..b42df7654 100644 --- a/src/video_core/renderer_opengl/renderer_opengl.h +++ b/src/video_core/renderer_opengl/renderer_opengl.h @@ -62,7 +62,6 @@ private: const TextureInfo& texture); EmuWindow* render_window; ///< Handle to render window - u32 last_mode; ///< Last render mode int resolution_width; ///< Current resolution width int resolution_height; ///< Current resolution height |