mirror/pineapple
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity

early-access version 3840

Browse source
This commit is contained in:
pineappleEA 2023-08-28 00:07:09 +02:00
parent d6da91ca90
commit 3cc2039405
19 changed files with 343 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -1,7 +1,7 @@
yuzu emulator early access
=============
This is the source code for early-access 3838.
This is the source code for early-access 3840.
## Legal Notice

7
src/audio_core/sink/cubeb_sink.cpp
View file

@ -364,7 +364,7 @@ bool IsCubebSuitable() {
}
#endif
// Test min latency
// Get min latency
cubeb_stream_params params{};
params.rate = TargetSampleRate;
params.channels = 2;
@ -380,11 +380,6 @@ bool IsCubebSuitable() {
}
latency = std::max(latency, TargetSampleCount * 2);
if (latency > TargetSampleCount * 3) {
LOG_ERROR(Audio_Sink, "Cubeb latency is too high, it is not suitable.");
return false;
}
// Test opening a device with standard parameters
cubeb_devid output_device{0};
cubeb_devid input_device{0};

4
src/audio_core/sink/sink_details.cpp
View file

@ -83,8 +83,8 @@ const SinkDetails& GetOutputSinkDetails(Settings::AudioEngine sink_id) {
break;
}
}
LOG_ERROR(Service_Audio, "Auto-selecting the {} backend",
Settings::CanonicalizeEnum(iter->id));
LOG_INFO(Service_Audio, "Auto-selecting the {} backend",
Settings::CanonicalizeEnum(iter->id));
} else {
if (iter != std::end(sink_details) && !iter->is_suitable()) {
LOG_ERROR(Service_Audio, "Selected backend {} is not suitable, falling back to null",

1
src/common/fs/fs_paths.h
View file

@ -18,6 +18,7 @@
#define LOAD_DIR "load"
#define LOG_DIR "log"
#define NAND_DIR "nand"
#define PLAY_TIME_DIR "play_time"
#define SCREENSHOTS_DIR "screenshots"
#define SDMC_DIR "sdmc"
#define SHADER_DIR "shader"

1
src/common/fs/path_util.cpp
View file

@ -122,6 +122,7 @@ public:
GenerateYuzuPath(YuzuPath::LoadDir, yuzu_path / LOAD_DIR);
GenerateYuzuPath(YuzuPath::LogDir, yuzu_path / LOG_DIR);
GenerateYuzuPath(YuzuPath::NANDDir, yuzu_path / NAND_DIR);
GenerateYuzuPath(YuzuPath::PlayTimeDir, yuzu_path / PLAY_TIME_DIR);
GenerateYuzuPath(YuzuPath::ScreenshotsDir, yuzu_path / SCREENSHOTS_DIR);
GenerateYuzuPath(YuzuPath::SDMCDir, yuzu_path / SDMC_DIR);
GenerateYuzuPath(YuzuPath::ShaderDir, yuzu_path / SHADER_DIR);

1
src/common/fs/path_util.h
View file

@ -20,6 +20,7 @@ enum class YuzuPath {
LoadDir, // Where cheat/mod files are stored.
LogDir, // Where log files are stored.
NANDDir, // Where the emulated NAND is stored.
PlayTimeDir, // Where play time data is stored.
ScreenshotsDir, // Where yuzu screenshots are stored.
SDMCDir, // Where the emulated SDMC is stored.
ShaderDir, // Where shaders are stored.

6
src/video_core/engines/maxwell_3d.cpp
View file

@ -255,6 +255,7 @@ u32 Maxwell3D::GetMaxCurrentVertices() {
const u32 address_size = static_cast<u32>(gpu_addr_end - gpu_addr_begin);
num_vertices = std::max(
num_vertices, address_size / std::max(attribute.SizeInBytes(), array.stride.Value()));
break;
}
return num_vertices;
}
@ -267,10 +268,13 @@ size_t Maxwell3D::EstimateIndexBufferSize() {
std::numeric_limits<u32>::max()};
const size_t byte_size = regs.index_buffer.FormatSizeInBytes();
const size_t log2_byte_size = Common::Log2Ceil64(byte_size);
const size_t cap{GetMaxCurrentVertices() * 3 * byte_size};
const size_t lower_cap =
std::min<size_t>(static_cast<size_t>(end_address - start_address), cap);
return std::min<size_t>(
memory_manager.GetMemoryLayoutSize(start_address, byte_size * max_sizes[log2_byte_size]) /
byte_size,
static_cast<size_t>(end_address - start_address));
lower_cap);
}
u32 Maxwell3D::ProcessShadowRam(u32 method, u32 argument) {

2
src/yuzu/CMakeLists.txt
View file

@ -195,6 +195,8 @@ add_executable(yuzu
multiplayer/state.cpp
multiplayer/state.h
multiplayer/validation.h
play_time.cpp
play_time.h
precompiled_headers.h
qt_common.cpp
qt_common.h

5
src/yuzu/configuration/configure_ui.cpp
View file

@ -126,6 +126,8 @@ ConfigureUi::ConfigureUi(Core::System& system_, QWidget* parent)
connect(ui->show_compat, &QCheckBox::stateChanged, this, &ConfigureUi::RequestGameListUpdate);
connect(ui->show_size, &QCheckBox::stateChanged, this, &ConfigureUi::RequestGameListUpdate);
connect(ui->show_types, &QCheckBox::stateChanged, this, &ConfigureUi::RequestGameListUpdate);
connect(ui->show_play_time, &QCheckBox::stateChanged, this,
&ConfigureUi::RequestGameListUpdate);
connect(ui->game_icon_size_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&ConfigureUi::RequestGameListUpdate);
connect(ui->folder_icon_size_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged),
@ -170,6 +172,7 @@ void ConfigureUi::ApplyConfiguration() {
UISettings::values.show_compat = ui->show_compat->isChecked();
UISettings::values.show_size = ui->show_size->isChecked();
UISettings::values.show_types = ui->show_types->isChecked();
UISettings::values.show_play_time = ui->show_play_time->isChecked();
UISettings::values.game_icon_size = ui->game_icon_size_combobox->currentData().toUInt();
UISettings::values.folder_icon_size = ui->folder_icon_size_combobox->currentData().toUInt();
UISettings::values.row_1_text_id = ui->row_1_text_combobox->currentData().toUInt();
@ -182,6 +185,7 @@ void ConfigureUi::ApplyConfiguration() {
const u32 height = ScreenshotDimensionToInt(ui->screenshot_height->currentText());
UISettings::values.screenshot_height.SetValue(height);
RequestGameListUpdate();
system.ApplySettings();
}
@ -197,6 +201,7 @@ void ConfigureUi::SetConfiguration() {
ui->show_compat->setChecked(UISettings::values.show_compat.GetValue());
ui->show_size->setChecked(UISettings::values.show_size.GetValue());
ui->show_types->setChecked(UISettings::values.show_types.GetValue());
ui->show_play_time->setChecked(UISettings::values.show_play_time.GetValue());
ui->game_icon_size_combobox->setCurrentIndex(
ui->game_icon_size_combobox->findData(UISettings::values.game_icon_size.GetValue()));
ui->folder_icon_size_combobox->setCurrentIndex(

7
src/yuzu/configuration/configure_ui.ui
View file

@ -104,6 +104,13 @@
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="show_play_time">
<property name="text">
<string>Show Play Time Column</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="game_icon_size_qhbox_layout_2">
<item>

6
src/yuzu/game_list.cpp
View file

@ -340,6 +340,7 @@ GameList::GameList(FileSys::VirtualFilesystem vfs_, FileSys::ManualContentProvid
tree_view->setColumnHidden(COLUMN_ADD_ONS, !UISettings::values.show_add_ons);
tree_view->setColumnHidden(COLUMN_COMPATIBILITY, !UISettings::values.show_compat);
tree_view->setColumnHidden(COLUMN_PLAY_TIME, !UISettings::values.show_play_time);
item_model->setSortRole(GameListItemPath::SortRole);
connect(main_window, &GMainWindow::UpdateThemedIcons, this, &GameList::OnUpdateThemedIcons);
@ -548,6 +549,7 @@ void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, const std::stri
QAction* remove_update = remove_menu->addAction(tr("Remove Installed Update"));
QAction* remove_dlc = remove_menu->addAction(tr("Remove All Installed DLC"));
QAction* remove_custom_config = remove_menu->addAction(tr("Remove Custom Configuration"));
QAction* remove_play_time_data = remove_menu->addAction(tr("Remove Play Time Data"));
QAction* remove_cache_storage = remove_menu->addAction(tr("Remove Cache Storage"));
QAction* remove_gl_shader_cache = remove_menu->addAction(tr("Remove OpenGL Pipeline Cache"));
QAction* remove_vk_shader_cache = remove_menu->addAction(tr("Remove Vulkan Pipeline Cache"));
@ -619,6 +621,8 @@ void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, const std::stri
connect(remove_custom_config, &QAction::triggered, [this, program_id, path]() {
emit RemoveFileRequested(program_id, GameListRemoveTarget::CustomConfiguration, path);
});
connect(remove_play_time_data, &QAction::triggered,
[this, program_id]() { emit RemovePlayTimeRequested(program_id); });
connect(remove_cache_storage, &QAction::triggered, [this, program_id, path] {
emit RemoveFileRequested(program_id, GameListRemoveTarget::CacheStorage, path);
});
@ -785,6 +789,7 @@ void GameList::RetranslateUI() {
item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
item_model->setHeaderData(COLUMN_PLAY_TIME, Qt::Horizontal, tr("Play time"));
}
void GameListSearchField::changeEvent(QEvent* event) {
@ -812,6 +817,7 @@ void GameList::PopulateAsync(QVector<UISettings::GameDir>& game_dirs) {
tree_view->setColumnHidden(COLUMN_COMPATIBILITY, !UISettings::values.show_compat);
tree_view->setColumnHidden(COLUMN_FILE_TYPE, !UISettings::values.show_types);
tree_view->setColumnHidden(COLUMN_SIZE, !UISettings::values.show_size);
tree_view->setColumnHidden(COLUMN_PLAY_TIME, !UISettings::values.show_play_time);
// Delete any rows that might already exist if we're repopulating
item_model->removeRows(0, item_model->rowCount());

2
src/yuzu/game_list.h
View file

@ -74,6 +74,7 @@ public:
COLUMN_ADD_ONS,
COLUMN_FILE_TYPE,
COLUMN_SIZE,
COLUMN_PLAY_TIME,
COLUMN_COUNT, // Number of columns
};
@ -112,6 +113,7 @@ signals:
void RemoveInstalledEntryRequested(u64 program_id, InstalledEntryType type);
void RemoveFileRequested(u64 program_id, GameListRemoveTarget target,
const std::string& game_path);
void RemovePlayTimeRequested(u64 program_id);
void DumpRomFSRequested(u64 program_id, const std::string& game_path, DumpRomFSTarget target);
void CopyTIDRequested(u64 program_id);
void CreateShortcut(u64 program_id, const std::string& game_path,

26
src/yuzu/game_list_p.h
View file

@ -18,6 +18,7 @@
#include "common/common_types.h"
#include "common/logging/log.h"
#include "common/string_util.h"
#include "yuzu/play_time.h"
#include "yuzu/uisettings.h"
#include "yuzu/util/util.h"
@ -221,6 +222,31 @@ public:
}
};
/**
* GameListItem for Play Time values.
* This object stores the play time of a game in seconds, and its readable
* representation in minutes/hours
*/
class GameListItemPlayTime : public GameListItem {
public:
static constexpr int PlayTimeRole = SortRole;
GameListItemPlayTime() = default;
explicit GameListItemPlayTime(const qulonglong time_seconds) {
setData(time_seconds, PlayTimeRole);
}
void setData(const QVariant& value, int role) override {
qulonglong time_seconds = value.toULongLong();
GameListItem::setData(PlayTime::ReadablePlayTime(time_seconds), Qt::DisplayRole);
GameListItem::setData(value, PlayTimeRole);
}
bool operator<(const QStandardItem& other) const override {
return data(PlayTimeRole).toULongLong() < other.data(PlayTimeRole).toULongLong();
}
};
class GameListDir : public GameListItem {
public:
static constexpr int GameDirRole = Qt::UserRole + 2;

2
src/yuzu/game_list_worker.cpp
View file

@ -27,6 +27,7 @@
#include "yuzu/game_list.h"
#include "yuzu/game_list_p.h"
#include "yuzu/game_list_worker.h"
#include "yuzu/play_time.h"
#include "yuzu/uisettings.h"
namespace {
@ -212,6 +213,7 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::stri
new GameListItemCompat(compatibility),
new GameListItem(file_type_string),
new GameListItemSize(size),
new GameListItemPlayTime(PlayTime::GetPlayTime(program_id)),
};
const auto patch_versions = GetGameListCachedObject(

26
src/yuzu/main.cpp
View file

@ -146,6 +146,7 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
#include "yuzu/install_dialog.h"
#include "yuzu/loading_screen.h"
#include "yuzu/main.h"
#include "yuzu/play_time.h"
#include "yuzu/startup_checks.h"
#include "yuzu/uisettings.h"
#include "yuzu/util/clickable_label.h"
@ -334,6 +335,8 @@ GMainWindow::GMainWindow(std::unique_ptr<Config> config_, bool has_broken_vulkan
SetDiscordEnabled(UISettings::values.enable_discord_presence.GetValue());
discord_rpc->Update();
play_time_manager = std::make_unique<PlayTime::PlayTimeManager>();
system->GetRoomNetwork().Init();
RegisterMetaTypes();
@ -1446,6 +1449,8 @@ void GMainWindow::ConnectWidgetEvents() {
connect(game_list, &GameList::RemoveInstalledEntryRequested, this,
&GMainWindow::OnGameListRemoveInstalledEntry);
connect(game_list, &GameList::RemoveFileRequested, this, &GMainWindow::OnGameListRemoveFile);
connect(game_list, &GameList::RemovePlayTimeRequested, this,
&GMainWindow::OnGameListRemovePlayTimeData);
connect(game_list, &GameList::DumpRomFSRequested, this, &GMainWindow::OnGameListDumpRomFS);
connect(game_list, &GameList::CopyTIDRequested, this, &GMainWindow::OnGameListCopyTID);
connect(game_list, &GameList::NavigateToGamedbEntryRequested, this,
@ -2466,6 +2471,20 @@ void GMainWindow::OnGameListRemoveFile(u64 program_id, GameListRemoveTarget targ
}
}
void GMainWindow::OnGameListRemovePlayTimeData(u64 program_id) {
if (QMessageBox::question(this, tr("Remove Play Time Data"), tr("Reset play time?"),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No) != QMessageBox::Yes) {
return;
}
if (!play_time_manager->ResetProgramPlayTime(program_id)) {
QMessageBox::warning(this, tr("Error Resetting Play Time Data"),
tr("Play time couldn't be cleared"));
return;
}
game_list->PopulateAsync(UISettings::values.game_dirs);
}
void GMainWindow::RemoveTransferableShaderCache(u64 program_id, GameListRemoveTarget target) {
const auto target_file_name = [target] {
switch (target) {
@ -3235,6 +3254,9 @@ void GMainWindow::OnStartGame() {
UpdateMenuState();
OnTasStateChanged();
play_time_manager->SetProgramId(system->GetApplicationProcessProgramID());
play_time_manager->Start();
discord_rpc->Update();
}
@ -3250,6 +3272,7 @@ void GMainWindow::OnRestartGame() {
void GMainWindow::OnPauseGame() {
emu_thread->SetRunning(false);
play_time_manager->Stop();
UpdateMenuState();
AllowOSSleep();
}
@ -3270,6 +3293,9 @@ void GMainWindow::OnStopGame() {
return;
}
play_time_manager->Stop();
// Update game list to show new play time
game_list->PopulateAsync(UISettings::values.game_dirs);
if (OnShutdownBegin()) {
OnShutdownBeginDialog();
} else {

7
src/yuzu/main.h
View file

@ -76,6 +76,10 @@ namespace DiscordRPC {
class DiscordInterface;
}
namespace PlayTime {
class PlayTimeManager;
}
namespace FileSys {
class ContentProvider;
class ManualContentProvider;
@ -312,6 +316,7 @@ private slots:
void OnGameListRemoveInstalledEntry(u64 program_id, InstalledEntryType type);
void OnGameListRemoveFile(u64 program_id, GameListRemoveTarget target,
const std::string& game_path);
void OnGameListRemovePlayTimeData(u64 program_id);
void OnGameListDumpRomFS(u64 program_id, const std::string& game_path, DumpRomFSTarget target);
void OnGameListCopyTID(u64 program_id);
void OnGameListNavigateToGamedbEntry(u64 program_id,
@ -374,6 +379,7 @@ private:
void RemoveVulkanDriverPipelineCache(u64 program_id);
void RemoveAllTransferableShaderCaches(u64 program_id);
void RemoveCustomConfiguration(u64 program_id, const std::string& game_path);
void RemovePlayTimeData(u64 program_id);
void RemoveCacheStorage(u64 program_id);
bool SelectRomFSDumpTarget(const FileSys::ContentProvider&, u64 program_id,
u64* selected_title_id, u8* selected_content_record_type);
@ -412,6 +418,7 @@ private:
std::unique_ptr<Core::System> system;
std::unique_ptr<DiscordRPC::DiscordInterface> discord_rpc;
std::unique_ptr<PlayTime::PlayTimeManager> play_time_manager;
std::shared_ptr<InputCommon::InputSubsystem> input_subsystem;
MultiplayerState* multiplayer_state = nullptr;

177
src/yuzu/play_time.cpp Executable file
View file

@ -0,0 +1,177 @@
// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "common/fs/file.h"
#include "common/fs/path_util.h"
#include "common/logging/log.h"
#include "common/settings.h"
#include "common/thread.h"
#include "core/hle/service/acc/profile_manager.h"
#include "yuzu/play_time.h"
namespace PlayTime {
void PlayTimeManager::SetProgramId(u64 program_id) {
this->running_program_id = program_id;
}
inline void PlayTimeManager::UpdateTimestamp() {
this->last_timestamp = std::chrono::steady_clock::now();
}
void PlayTimeManager::Start() {
UpdateTimestamp();
play_time_thread =
std::jthread([&](std::stop_token stop_token) { this->AutoTimestamp(stop_token); });
}
void PlayTimeManager::Stop() {
play_time_thread.request_stop();
}
void PlayTimeManager::AutoTimestamp(std::stop_token stop_token) {
Common::SetCurrentThreadName("PlayTimeReport");
using namespace std::literals::chrono_literals;
const auto duration = 30s;
while (Common::StoppableTimedWait(stop_token, duration)) {
Save();
}
Save();
}
void PlayTimeManager::Save() {
const auto now = std::chrono::steady_clock::now();
const auto duration =
static_cast<u64>(std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::steady_clock::duration(now - this->last_timestamp))
.count());
UpdateTimestamp();
if (!UpdatePlayTime(running_program_id, duration)) {
LOG_ERROR(Common, "Failed to update play time");
}
}
bool UpdatePlayTime(u64 program_id, u64 add_play_time) {
std::vector<PlayTimeElement> play_time_elements;
if (!ReadPlayTimeFile(play_time_elements)) {
return false;
}
const auto it = std::find(play_time_elements.begin(), play_time_elements.end(), program_id);
if (it == play_time_elements.end()) {
play_time_elements.push_back({.program_id = program_id, .play_time = add_play_time});
} else {
play_time_elements.at(it - play_time_elements.begin()).play_time += add_play_time;
}
if (!WritePlayTimeFile(play_time_elements)) {
return false;
}
return true;
}
u64 GetPlayTime(u64 program_id) {
std::vector<PlayTimeElement> play_time_elements;
if (!ReadPlayTimeFile(play_time_elements)) {
return 0;
}
const auto it = std::find(play_time_elements.begin(), play_time_elements.end(), program_id);
if (it == play_time_elements.end()) {
return 0;
}
return play_time_elements.at(it - play_time_elements.begin()).play_time;
}
bool PlayTimeManager::ResetProgramPlayTime(u64 program_id) {
std::vector<PlayTimeElement> play_time_elements;
if (!ReadPlayTimeFile(play_time_elements)) {
return false;
}
const auto it = std::find(play_time_elements.begin(), play_time_elements.end(), program_id);
if (it == play_time_elements.end()) {
return false;
}
play_time_elements.erase(it);
if (!WritePlayTimeFile(play_time_elements)) {
return false;
}
return true;
}
std::optional<std::filesystem::path> GetCurrentUserPlayTimePath() {
const Service::Account::ProfileManager manager;
const auto uuid = manager.GetUser(static_cast<s32>(Settings::values.current_user));
if (!uuid.has_value()) {
return std::nullopt;
}
return Common::FS::GetYuzuPath(Common::FS::YuzuPath::PlayTimeDir) /
uuid->RawString().append(".bin");
}
[[nodiscard]] bool ReadPlayTimeFile(std::vector<PlayTimeElement>& out_play_time_elements) {
const auto filename = GetCurrentUserPlayTimePath();
if (!filename.has_value()) {
LOG_ERROR(Common, "Failed to get current user path");
return false;
}
if (Common::FS::Exists(filename.value())) {
Common::FS::IOFile file{filename.value(), Common::FS::FileAccessMode::Read,
Common::FS::FileType::BinaryFile};
if (!file.IsOpen()) {
LOG_ERROR(Common, "Failed to open play time file: {}",
Common::FS::PathToUTF8String(filename.value()));
return false;
}
const size_t elem_num = file.GetSize() / sizeof(PlayTimeElement);
out_play_time_elements.resize(elem_num);
const bool success = file.ReadSpan<PlayTimeElement>(out_play_time_elements) == elem_num;
file.Close();
return success;
} else {
out_play_time_elements.clear();
return true;
}
}
[[nodiscard]] bool WritePlayTimeFile(const std::vector<PlayTimeElement>& play_time_elements) {
const auto filename = GetCurrentUserPlayTimePath();
if (!filename.has_value()) {
LOG_ERROR(Common, "Failed to get current user path");
return false;
}
Common::FS::IOFile file{filename.value(), Common::FS::FileAccessMode::Write,
Common::FS::FileType::BinaryFile};
if (!file.IsOpen()) {
LOG_ERROR(Common, "Failed to open play time file: {}",
Common::FS::PathToUTF8String(filename.value()));
return false;
}
const bool success =
file.WriteSpan<PlayTimeElement>(play_time_elements) == play_time_elements.size();
file.Close();
return success;
}
QString ReadablePlayTime(qulonglong time_seconds) {
static constexpr std::array units{"m", "h"};
if (time_seconds == 0) {
return QLatin1String("");
}
const auto time_minutes = std::max(static_cast<double>(time_seconds) / 60, 1.0);
const auto time_hours = static_cast<double>(time_seconds) / 3600;
const int unit = time_minutes < 60 ? 0 : 1;
const auto value = unit == 0 ? time_minutes : time_hours;
return QStringLiteral("%L1 %2")
.arg(value, 0, 'f', unit && time_seconds % 60 != 0)
.arg(QString::fromUtf8(units[unit]));
}
} // namespace PlayTime

68
src/yuzu/play_time.h Executable file
View file

@ -0,0 +1,68 @@
// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <QString>
#include <atomic>
#include <condition_variable>
#include <mutex>
#include <optional>
#include <thread>
#include "common/common_types.h"
#include "common/fs/fs.h"
#include "common/polyfill_thread.h"
#include "core/core.h"
namespace PlayTime {
struct PlayTimeElement {
u64 program_id;
u64 play_time;
inline bool operator==(const PlayTimeElement& other) const {
return program_id == other.program_id;
}
inline bool operator==(const u64 _program_id) const {
return program_id == _program_id;
}
};
class PlayTimeManager {
public:
explicit PlayTimeManager() = default;
~PlayTimeManager() = default;
public:
YUZU_NON_COPYABLE(PlayTimeManager);
YUZU_NON_MOVEABLE(PlayTimeManager);
public:
bool ResetProgramPlayTime(u64 program_id);
void SetProgramId(u64 program_id);
inline void UpdateTimestamp();
void Start();
void Stop();
private:
u64 running_program_id;
std::chrono::steady_clock::time_point last_timestamp;
std::jthread play_time_thread;
void AutoTimestamp(std::stop_token stop_token);
void Save();
};
std::optional<std::filesystem::path> GetCurrentUserPlayTimePath();
bool UpdatePlayTime(u64 program_id, u64 add_play_time);
[[nodiscard]] bool ReadPlayTimeFile(std::vector<PlayTimeElement>& out_play_time_elements);
[[nodiscard]] bool WritePlayTimeFile(const std::vector<PlayTimeElement>& play_time_elements);
u64 GetPlayTime(u64 program_id);
QString ReadablePlayTime(qulonglong time_seconds);
} // namespace PlayTime

3
src/yuzu/uisettings.h
View file

@ -183,6 +183,9 @@ struct Values {
Setting<bool> show_size{linkage, true, "show_size", Category::UiGameList};
Setting<bool> show_types{linkage, true, "show_types", Category::UiGameList};
// Play time
Setting<bool> show_play_time{linkage, true, "show_play_time", Category::UiGameList};
bool configuration_applied;
bool reset_to_defaults;
bool shortcut_already_warned{false};