diff --git a/CMakeLists.txt b/CMakeLists.txt index 147903a7e88..3d69da66012 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -623,8 +623,10 @@ set(NP_LIBS src/core/libraries/np/np_error.h src/core/libraries/np/np_party.h src/core/libraries/np/np_auth.cpp src/core/libraries/np/np_auth.h - src/core/libraries/np/np_profile_dialog.cpp - src/core/libraries/np/np_profile_dialog.h + src/core/libraries/np/np_profile_dialog/np_profile_dialog.cpp + src/core/libraries/np/np_profile_dialog/np_profile_dialog.h + src/core/libraries/np/np_profile_dialog/np_profile_dialog_ui.cpp + src/core/libraries/np/np_profile_dialog/np_profile_dialog_ui.h src/core/libraries/np/np_sns_facebook_dialog.cpp src/core/libraries/np/np_sns_facebook_dialog.h src/core/libraries/np/np_partner.cpp diff --git a/src/core/libraries/libs.cpp b/src/core/libraries/libs.cpp index 762753fd1b6..d207126bc37 100644 --- a/src/core/libraries/libs.cpp +++ b/src/core/libraries/libs.cpp @@ -38,7 +38,7 @@ #include "core/libraries/np/np_matching2.h" #include "core/libraries/np/np_partner.h" #include "core/libraries/np/np_party.h" -#include "core/libraries/np/np_profile_dialog.h" +#include "core/libraries/np/np_profile_dialog/np_profile_dialog.h" #include "core/libraries/np/np_score.h" #include "core/libraries/np/np_sns_facebook_dialog.h" #include "core/libraries/np/np_trophy.h" diff --git a/src/core/libraries/np/np_profile_dialog.cpp b/src/core/libraries/np/np_profile_dialog.cpp deleted file mode 100644 index 6ae1ed26cd5..00000000000 --- a/src/core/libraries/np/np_profile_dialog.cpp +++ /dev/null @@ -1,72 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include "common/logging/log.h" -#include "core/libraries/error_codes.h" -#include "core/libraries/libs.h" -#include "core/libraries/np/np_profile_dialog.h" - -namespace Libraries::Np::NpProfileDialog { - -s32 PS4_SYSV_ABI sceNpProfileDialogOpen() { - LOG_ERROR(Lib_NpProfileDialog, "(STUBBED) called"); - return ORBIS_OK; -} - -s32 PS4_SYSV_ABI sceNpProfileDialogClose() { - LOG_ERROR(Lib_NpProfileDialog, "(STUBBED) called"); - return ORBIS_OK; -} - -s32 PS4_SYSV_ABI sceNpProfileDialogGetResult() { - LOG_ERROR(Lib_NpProfileDialog, "(STUBBED) called"); - return ORBIS_OK; -} - -s32 PS4_SYSV_ABI sceNpProfileDialogGetStatus() { - LOG_ERROR(Lib_NpProfileDialog, "(STUBBED) called"); - return ORBIS_OK; -} - -s32 PS4_SYSV_ABI sceNpProfileDialogInitialize() { - LOG_ERROR(Lib_NpProfileDialog, "(STUBBED) called"); - return ORBIS_OK; -} - -s32 PS4_SYSV_ABI sceNpProfileDialogOpenA() { - LOG_ERROR(Lib_NpProfileDialog, "(STUBBED) called"); - return ORBIS_OK; -} - -s32 PS4_SYSV_ABI sceNpProfileDialogTerminate() { - LOG_ERROR(Lib_NpProfileDialog, "(STUBBED) called"); - return ORBIS_OK; -} - -s32 PS4_SYSV_ABI sceNpProfileDialogUpdateStatus() { - LOG_DEBUG(Lib_NpProfileDialog, "(STUBBED) called"); - return ORBIS_OK; -} - -void RegisterLib(Core::Loader::SymbolsResolver* sym) { - LIB_FUNCTION("uj9Cz7Tk0cc", "libSceNpProfileDialogCompat", 1, "libSceNpProfileDialog", - sceNpProfileDialogOpen); - LIB_FUNCTION("wkwjz0Xdo2A", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", - sceNpProfileDialogClose); - LIB_FUNCTION("8rhLl1-0W-o", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", - sceNpProfileDialogGetResult); - LIB_FUNCTION("3BqoiFOjSsk", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", - sceNpProfileDialogGetStatus); - LIB_FUNCTION("Lg+NCE6pTwQ", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", - sceNpProfileDialogInitialize); - LIB_FUNCTION("uj9Cz7Tk0cc", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", - sceNpProfileDialogOpen); - LIB_FUNCTION("nrQRlLKzdwE", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", - sceNpProfileDialogOpenA); - LIB_FUNCTION("0Sp9vJcB1-w", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", - sceNpProfileDialogTerminate); - LIB_FUNCTION("haVZE9FgKqE", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", - sceNpProfileDialogUpdateStatus); -}; - -} // namespace Libraries::Np::NpProfileDialog \ No newline at end of file diff --git a/src/core/libraries/np/np_profile_dialog.h b/src/core/libraries/np/np_profile_dialog.h deleted file mode 100644 index ca1126d579d..00000000000 --- a/src/core/libraries/np/np_profile_dialog.h +++ /dev/null @@ -1,24 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include "common/types.h" - -namespace Core::Loader { -class SymbolsResolver; -} - -namespace Libraries::Np::NpProfileDialog { - -s32 PS4_SYSV_ABI sceNpProfileDialogOpen(); -s32 PS4_SYSV_ABI sceNpProfileDialogClose(); -s32 PS4_SYSV_ABI sceNpProfileDialogGetResult(); -s32 PS4_SYSV_ABI sceNpProfileDialogGetStatus(); -s32 PS4_SYSV_ABI sceNpProfileDialogInitialize(); -s32 PS4_SYSV_ABI sceNpProfileDialogOpenA(); -s32 PS4_SYSV_ABI sceNpProfileDialogTerminate(); -s32 PS4_SYSV_ABI sceNpProfileDialogUpdateStatus(); - -void RegisterLib(Core::Loader::SymbolsResolver* sym); -} // namespace Libraries::Np::NpProfileDialog \ No newline at end of file diff --git a/src/core/libraries/np/np_profile_dialog/np_profile_dialog.cpp b/src/core/libraries/np/np_profile_dialog/np_profile_dialog.cpp new file mode 100644 index 00000000000..932a3c374e4 --- /dev/null +++ b/src/core/libraries/np/np_profile_dialog/np_profile_dialog.cpp @@ -0,0 +1,201 @@ +// SPDX-FileCopyrightText: Copyright 2025-2026 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include +#include "common/logging/log.h" +#include "core/libraries/error_codes.h" +#include "core/libraries/libs.h" +#include "magic_enum/magic_enum.hpp" +#include "np_profile_dialog.h" +#include "np_profile_dialog_ui.h" + +namespace Libraries::Np::NpProfileDialog { + +static auto g_status = Libraries::CommonDialog::Status::NONE; +static NpProfileDialogState g_state{}; +static OrbisNpProfileDialogResult g_result{}; +static NpProfileDialogUi g_profile_dialog_ui; + +Libraries::CommonDialog::Error sceNpProfileDialogOpen(OrbisNpProfileDialogParam* param) { + if (g_status != Libraries::CommonDialog::Status::INITIALIZED && + g_status != Libraries::CommonDialog::Status::FINISHED) { + LOG_ERROR(Lib_NpProfileDialog, "called without initialize"); + return Libraries::CommonDialog::Error::INVALID_STATE; + } + if (param == nullptr) { + LOG_ERROR(Lib_NpProfileDialog, "param is nullptr"); + return Libraries::CommonDialog::Error::ARG_NULL; + } + + LOG_DEBUG(Lib_NpProfileDialog, + "param details: mode={}, userId={}, targetOnlineId='{}', userData={}", + static_cast(param->mode), param->userId, param->targetOnlineId.data, + fmt::ptr(param->userData)); + + NpProfileDialogState state{}; + state.onlineId = std::string(param->targetOnlineId.data); + state.hasAccountId = false; + state.mode = param->mode; + state.userId = param->userId; + g_state = state; + g_result = {}; + g_result.userData = param->userData; + g_status = Libraries::CommonDialog::Status::RUNNING; + + LOG_DEBUG(Lib_NpProfileDialog, "creating UI with onlineId='{}', mode={}, userId={}", + state.onlineId, static_cast(state.mode), state.userId); + + g_profile_dialog_ui = NpProfileDialogUi(&g_state, &g_status, &g_result); + + LOG_INFO(Lib_NpProfileDialog, "dialog opened successfully for user {}", param->userId); + return Libraries::CommonDialog::Error::OK; +} + +Libraries::CommonDialog::Error PS4_SYSV_ABI sceNpProfileDialogClose() { + LOG_DEBUG(Lib_NpProfileDialog, "called"); + if (g_status == Libraries::CommonDialog::Status::NONE) { + return Libraries::CommonDialog::Error::NOT_INITIALIZED; + } + if (g_status != Libraries::CommonDialog::Status::RUNNING) { + return Libraries::CommonDialog::Error::NOT_RUNNING; + } + g_profile_dialog_ui.Finish(Libraries::CommonDialog::Result::OK); + return Libraries::CommonDialog::Error::OK; +} + +Libraries::CommonDialog::Error PS4_SYSV_ABI +sceNpProfileDialogGetResult(OrbisNpProfileDialogResult* result) { + LOG_DEBUG(Lib_NpProfileDialog, "called"); + + if (g_status == Libraries::CommonDialog::Status::NONE) { + LOG_ERROR(Lib_NpProfileDialog, "failed: not initialized (g_status=NONE)"); + return Libraries::CommonDialog::Error::NOT_INITIALIZED; + } + if (result == nullptr) { + LOG_ERROR(Lib_NpProfileDialog, "failed: result pointer is nullptr"); + return Libraries::CommonDialog::Error::ARG_NULL; + } + if (g_status != Libraries::CommonDialog::Status::FINISHED) { + LOG_ERROR(Lib_NpProfileDialog, "failed: dialog not finished (g_status={})", + static_cast(g_status)); + return Libraries::CommonDialog::Error::NOT_FINISHED; + } + + *result = g_result; + + LOG_DEBUG(Lib_NpProfileDialog, "result details: resultCode={}, userAction={}, userData={}", + g_result.result, static_cast(g_result.userAction), fmt::ptr(g_result.userData)); + return Libraries::CommonDialog::Error::OK; +} + +Libraries::CommonDialog::Status PS4_SYSV_ABI sceNpProfileDialogGetStatus() { + LOG_TRACE(Lib_NpProfileDialog, "called status={}", magic_enum::enum_name(g_status)); + return g_status; +} + +Libraries::CommonDialog::Error PS4_SYSV_ABI sceNpProfileDialogInitialize() { + if (!CommonDialog::g_isInitialized) { + LOG_ERROR(Lib_NpProfileDialog, "failed: system not initialized"); + return Libraries::CommonDialog::Error::NOT_SYSTEM_INITIALIZED; + } + if (g_status != Libraries::CommonDialog::Status::NONE) { + LOG_ERROR(Lib_NpProfileDialog, "failed: already initialized (g_status={})", + static_cast(g_status)); + return Libraries::CommonDialog::Error::ALREADY_INITIALIZED; + } + if (CommonDialog::g_isUsed) { + LOG_ERROR(Lib_NpProfileDialog, "failed: dialog system busy (g_isUsed=true)"); + return Libraries::CommonDialog::Error::BUSY; + } + + g_status = Libraries::CommonDialog::Status::INITIALIZED; + CommonDialog::g_isUsed = true; + LOG_INFO(Lib_NpProfileDialog, "initialized successfully"); + return Libraries::CommonDialog::Error::OK; +} + +Libraries::CommonDialog::Error PS4_SYSV_ABI +sceNpProfileDialogOpenA(OrbisNpProfileDialogParamA* param) { + if (g_status != Libraries::CommonDialog::Status::INITIALIZED && + g_status != Libraries::CommonDialog::Status::FINISHED) { + LOG_ERROR(Lib_NpProfileDialog, "called without initialize"); + return Libraries::CommonDialog::Error::INVALID_STATE; + } + if (param == nullptr) { + LOG_ERROR(Lib_NpProfileDialog, "failed: param is nullptr"); + return Libraries::CommonDialog::Error::ARG_NULL; + } + + LOG_DEBUG(Lib_NpProfileDialog, + "param details: mode={}, userId={}, targetAccountId='{}', userData={}", + static_cast(param->mode), param->userId, param->targetAccountId, + fmt::ptr(param->userData)); + LOG_ERROR(Lib_NpProfileDialog, "(STUBBED) called"); + + NpProfileDialogState state{}; + state.accountId = param->targetAccountId; + state.hasAccountId = true; + state.mode = param->mode; + state.userId = param->userId; + g_state = state; + g_result = {}; + g_result.userData = param->userData; + g_status = Libraries::CommonDialog::Status::RUNNING; + + LOG_DEBUG(Lib_NpProfileDialog, "creating UI with accountId='{}', mode={}, userId={}", + state.accountId, static_cast(state.mode), state.userId); + + g_profile_dialog_ui = NpProfileDialogUi(&g_state, &g_status, &g_result); + + LOG_INFO(Lib_NpProfileDialog, "dialog opened successfully for user {} (account ID variant)", + param->userId); + return Libraries::CommonDialog::Error::OK; +} + +Libraries::CommonDialog::Error PS4_SYSV_ABI sceNpProfileDialogTerminate() { + LOG_DEBUG(Lib_NpProfileDialog, "called (g_status={})", static_cast(g_status)); + + if (g_status == Libraries::CommonDialog::Status::RUNNING) { + LOG_ERROR(Lib_NpProfileDialog, "dialog is running, closing it first"); + sceNpProfileDialogClose(); + } + if (g_status == Libraries::CommonDialog::Status::NONE) { + LOG_ERROR(Lib_NpProfileDialog, "failed: not initialized (g_status=NONE)"); + return Libraries::CommonDialog::Error::NOT_INITIALIZED; + } + + g_status = Libraries::CommonDialog::Status::NONE; + CommonDialog::g_isUsed = false; + + LOG_INFO(Lib_NpProfileDialog, "terminated successfully"); + return Libraries::CommonDialog::Error::OK; +} + +Libraries::CommonDialog::Status PS4_SYSV_ABI sceNpProfileDialogUpdateStatus() { + LOG_TRACE(Lib_NpProfileDialog, "called status={}", magic_enum::enum_name(g_status)); + return g_status; +} + +void RegisterLib(Core::Loader::SymbolsResolver* sym) { + LIB_FUNCTION("uj9Cz7Tk0cc", "libSceNpProfileDialogCompat", 1, "libSceNpProfileDialog", + sceNpProfileDialogOpen); + LIB_FUNCTION("wkwjz0Xdo2A", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", + sceNpProfileDialogClose); + LIB_FUNCTION("8rhLl1-0W-o", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", + sceNpProfileDialogGetResult); + LIB_FUNCTION("3BqoiFOjSsk", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", + sceNpProfileDialogGetStatus); + LIB_FUNCTION("Lg+NCE6pTwQ", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", + sceNpProfileDialogInitialize); + LIB_FUNCTION("uj9Cz7Tk0cc", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", + sceNpProfileDialogOpen); + LIB_FUNCTION("nrQRlLKzdwE", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", + sceNpProfileDialogOpenA); + LIB_FUNCTION("0Sp9vJcB1-w", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", + sceNpProfileDialogTerminate); + LIB_FUNCTION("haVZE9FgKqE", "libSceNpProfileDialog", 1, "libSceNpProfileDialog", + sceNpProfileDialogUpdateStatus); +}; + +} // namespace Libraries::Np::NpProfileDialog diff --git a/src/core/libraries/np/np_profile_dialog/np_profile_dialog.h b/src/core/libraries/np/np_profile_dialog/np_profile_dialog.h new file mode 100644 index 00000000000..c885a7db0bd --- /dev/null +++ b/src/core/libraries/np/np_profile_dialog/np_profile_dialog.h @@ -0,0 +1,80 @@ +// SPDX-FileCopyrightText: Copyright 2025-2026 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include "common/types.h" +#include "core/libraries/np/np_types.h" + +namespace Core::Loader { +class SymbolsResolver; +} + +namespace Libraries::Np::NpProfileDialog { + +enum class OrbisNpProfileDialogMode : u32 { + ORBIS_NP_PROFILE_DIALOG_MODE_INVALID = 0, + ORBIS_NP_PROFILE_DIALOG_MODE_NORMAL = 1, + ORBIS_NP_PROFILE_DIALOG_MODE_FRIEND_REQUEST = 2, + ORBIS_NP_PROFILE_DIALOG_MODE_ADD_TO_BLOCK_LIST = 3, + ORBIS_NP_PROFILE_DIALOG_MODE_GRIEF_REPORT = 4, +}; + +static constexpr s32 ORBIS_NP_PROFILE_DIALOG_MENU_GRIEF_REPORT_ITEM_INVALID = 0x00000000; +static constexpr s32 ORBIS_NP_PROFILE_DIALOG_MENU_GRIEF_REPORT_ITEM_ONLINE_ID = 0x00000001; +static constexpr s32 ORBIS_NP_PROFILE_DIALOG_MENU_GRIEF_REPORT_ITEM_NAME = 0x00000002; +static constexpr s32 ORBIS_NP_PROFILE_DIALOG_MENU_GRIEF_REPORT_ITEM_PICTURE = 0x00000004; +static constexpr s32 ORBIS_NP_PROFILE_DIALOG_MENU_GRIEF_REPORT_ITEM_ABOUT_ME = 0x00000008; + +struct OrbisNpProfileDialogParam { + CommonDialog::BaseParam baseParam; + u64 size; + OrbisNpProfileDialogMode mode; + Libraries::UserService::OrbisUserServiceUserId userId; + Libraries::Np::OrbisNpOnlineId targetOnlineId; + void* userData; + u8 reserved[32]; +}; + +struct OrbisNpProfileGriefReportParam { + s32 reportItem; + u8 reserved[28]; +}; + +struct OrbisNpProfileDialogParamA { + CommonDialog::BaseParam baseParam; + u64 size; + OrbisNpProfileDialogMode mode; + Libraries::UserService::OrbisUserServiceUserId userId; + Libraries::Np::OrbisNpAccountId targetAccountId; + int : 32; + void* userData; + union { + uint8_t reserved[32]; + OrbisNpProfileGriefReportParam griefReportParam; + }; +}; + +struct OrbisNpProfileDialogResult { + s32 result; + CommonDialog::Result userAction; + void* userData; + u8 reserved[32]; +}; + +Libraries::CommonDialog::Error PS4_SYSV_ABI +sceNpProfileDialogOpen(OrbisNpProfileDialogParam* param); +Libraries::CommonDialog::Error PS4_SYSV_ABI sceNpProfileDialogClose(); +Libraries::CommonDialog::Error PS4_SYSV_ABI +sceNpProfileDialogGetResult(OrbisNpProfileDialogResult* result); +Libraries::CommonDialog::Status PS4_SYSV_ABI sceNpProfileDialogGetStatus(); +Libraries::CommonDialog::Error PS4_SYSV_ABI sceNpProfileDialogInitialize(); +Libraries::CommonDialog::Error PS4_SYSV_ABI +sceNpProfileDialogOpenA(OrbisNpProfileDialogParamA* param); +Libraries::CommonDialog::Error PS4_SYSV_ABI sceNpProfileDialogTerminate(); +Libraries::CommonDialog::Status PS4_SYSV_ABI sceNpProfileDialogUpdateStatus(); + +void RegisterLib(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::Np::NpProfileDialog diff --git a/src/core/libraries/np/np_profile_dialog/np_profile_dialog_ui.cpp b/src/core/libraries/np/np_profile_dialog/np_profile_dialog_ui.cpp new file mode 100644 index 00000000000..b96d1879f38 --- /dev/null +++ b/src/core/libraries/np/np_profile_dialog/np_profile_dialog_ui.cpp @@ -0,0 +1,279 @@ +// SPDX-FileCopyrightText: Copyright 2025-2026 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include +#include +#include + +#include +#include +#include "np_profile_dialog_ui.h" + +using namespace ImGui; +using namespace Libraries::CommonDialog; + +namespace Libraries::Np::NpProfileDialog { + +// PS4 color palette +static constexpr ImVec4 COL_OVERLAY = {0.00f, 0.00f, 0.00f, 0.65f}; +static constexpr ImVec4 COL_HEADER_TOP = {0.00f, 0.34f, 0.62f, 1.00f}; +static constexpr ImVec4 COL_HEADER_BOT = {0.00f, 0.22f, 0.42f, 1.00f}; +static constexpr ImVec4 COL_CARD_BG = {0.11f, 0.11f, 0.12f, 1.00f}; +static constexpr ImVec4 COL_SEPARATOR = {0.22f, 0.22f, 0.24f, 1.00f}; +static constexpr ImVec4 COL_AVATAR_BG = {0.18f, 0.18f, 0.20f, 1.00f}; +static constexpr ImVec4 COL_AVATAR_OUTLINE = {0.00f, 0.44f, 0.75f, 1.00f}; +static constexpr ImVec4 COL_TEXT_PRIMARY = {1.00f, 1.00f, 1.00f, 1.00f}; +static constexpr ImVec4 COL_TEXT_SECONDARY = {0.65f, 0.65f, 0.68f, 1.00f}; +static constexpr ImVec4 COL_BUTTON_NORMAL = {0.18f, 0.18f, 0.20f, 1.00f}; +static constexpr ImVec4 COL_BUTTON_HOVERED = {0.00f, 0.44f, 0.75f, 1.00f}; +static constexpr ImVec4 COL_BUTTON_ACTIVE = {0.00f, 0.33f, 0.60f, 1.00f}; +static constexpr ImVec4 COL_BUTTON_BORDER = {0.32f, 0.32f, 0.35f, 1.00f}; + +static constexpr float CARD_WIDTH = 480.0f; +static constexpr float CARD_HEIGHT = 330.0f; +static constexpr float HEADER_HEIGHT = 44.0f; +static constexpr float FOOTER_HEIGHT = 56.0f; +static constexpr float AVATAR_RADIUS = 44.0f; +static constexpr float AVATAR_REL_X = CARD_WIDTH * 0.5f; +static constexpr float AVATAR_REL_Y = HEADER_HEIGHT + AVATAR_RADIUS + 16.0f; +static constexpr float FADE_SPEED = 8.0f; +static constexpr ImVec2 CLOSE_BUTTON_SIZE = {110.0f, 34.0f}; + +static ImU32 AlphaScale(ImVec4 col, float alpha) { + col.w *= alpha; + return GetColorU32(col); +} + +static void DrawCardShadow(ImDrawList* dl, ImVec2 min, ImVec2 max, float alpha) { + for (int i = 0; i < 6; ++i) { + const float spread = (float)(i + 1) * 3.5f; + const float a = alpha * (0.28f - (float)i * 0.04f); + if (a <= 0.0f) + break; + dl->AddRectFilled({min.x - spread, min.y + spread}, {max.x + spread, max.y + spread * 1.5f}, + IM_COL32(0, 0, 0, (int)(a * 255.0f)), 8.0f + spread); + } +} + +static void DrawAvatarPlaceholder(ImDrawList* dl, ImVec2 center, float radius, float alpha) { + const ImU32 bg_col = AlphaScale(COL_AVATAR_BG, alpha); + const ImU32 outline_col = AlphaScale(COL_AVATAR_OUTLINE, alpha); + const ImU32 silhouette = IM_COL32(90, 90, 96, (int)(alpha * 255.0f)); + + dl->AddCircleFilled(center, radius, bg_col, 64); + + dl->AddCircleFilled({center.x, center.y - radius * 0.18f}, radius * 0.32f, silhouette, 32); + + dl->AddCircleFilled({center.x, center.y + radius * 0.45f}, radius * 0.55f, silhouette, 48); + + // Outline drawn last — sits on top of silhouette + dl->AddCircle(center, radius, outline_col, 64, 2.5f); +} + +static const char* GetModeTitle(OrbisNpProfileDialogMode mode) { + switch (mode) { + case OrbisNpProfileDialogMode::ORBIS_NP_PROFILE_DIALOG_MODE_NORMAL: + return "Profile"; + case OrbisNpProfileDialogMode::ORBIS_NP_PROFILE_DIALOG_MODE_FRIEND_REQUEST: + return "Friend Request"; + case OrbisNpProfileDialogMode::ORBIS_NP_PROFILE_DIALOG_MODE_ADD_TO_BLOCK_LIST: + return "Block List"; + case OrbisNpProfileDialogMode::ORBIS_NP_PROFILE_DIALOG_MODE_GRIEF_REPORT: + return "Report"; + default: + return "Profile"; + } +} + +static const char* GetModeSubtitle(OrbisNpProfileDialogMode mode) { + switch (mode) { + case OrbisNpProfileDialogMode::ORBIS_NP_PROFILE_DIALOG_MODE_NORMAL: + return "Player Profile"; + case OrbisNpProfileDialogMode::ORBIS_NP_PROFILE_DIALOG_MODE_FRIEND_REQUEST: + return "Send Friend Request"; + case OrbisNpProfileDialogMode::ORBIS_NP_PROFILE_DIALOG_MODE_ADD_TO_BLOCK_LIST: + return "Add to Block List"; + case OrbisNpProfileDialogMode::ORBIS_NP_PROFILE_DIALOG_MODE_GRIEF_REPORT: + return "Report Player"; + default: + return "Player Profile"; + } +} + +NpProfileDialogUi::NpProfileDialogUi(NpProfileDialogState* state, Status* status, + OrbisNpProfileDialogResult* result) + : state(state), status(status), result(result) { + if (status && *status == Status::RUNNING) { + first_render = true; + open_alpha = 0.0f; + AddLayer(this); + } +} + +NpProfileDialogUi::~NpProfileDialogUi() { + Finish(Result::USER_CANCELED); +} + +NpProfileDialogUi::NpProfileDialogUi(NpProfileDialogUi&& other) noexcept + : Layer(other), state(other.state), status(other.status), result(other.result), + open_alpha(other.open_alpha) { + other.state = nullptr; + other.status = nullptr; + other.result = nullptr; + other.open_alpha = 0.0f; +} + +NpProfileDialogUi& NpProfileDialogUi::operator=(NpProfileDialogUi other) { + using std::swap; + swap(state, other.state); + swap(status, other.status); + swap(result, other.result); + swap(open_alpha, other.open_alpha); + if (status && *status == Status::RUNNING) { + first_render = true; + open_alpha = 0.0f; + AddLayer(this); + } + return *this; +} + +void NpProfileDialogUi::Finish(Result user_action) { + if (result) { + result->result = 0; // ORBIS_OK + result->userAction = user_action; + } + if (status) { + *status = Status::FINISHED; + } + state = nullptr; + status = nullptr; + result = nullptr; + RemoveLayer(this); +} + +void NpProfileDialogUi::Draw() { + if (status == nullptr || *status != Status::RUNNING) { + return; + } + + const auto& io = GetIO(); + open_alpha = std::fmin(open_alpha + io.DeltaTime * FADE_SPEED, 1.0f); + + const float card_x = (io.DisplaySize.x - CARD_WIDTH) * 0.5f; + const float card_y = (io.DisplaySize.y - CARD_HEIGHT) * 0.5f; + const ImVec2 card_min = {card_x, card_y}; + const ImVec2 card_max = {card_x + CARD_WIDTH, card_y + CARD_HEIGHT}; + + SetNextWindowPos({0, 0}); + SetNextWindowSize(io.DisplaySize); + PushStyleColor(ImGuiCol_WindowBg, AlphaScale(COL_OVERLAY, open_alpha)); + PushStyleVar(ImGuiStyleVar_WindowPadding, {0.0f, 0.0f}); + Begin("##NpProfileDialogOverlay", nullptr, + ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoSavedSettings | + ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoNav | + ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoFocusOnAppearing); + End(); + PopStyleVar(); + PopStyleColor(); + + SetNextWindowPos(card_min); + SetNextWindowSize({CARD_WIDTH, CARD_HEIGHT}); + SetNextWindowCollapsed(false); + if (first_render || !io.NavActive) { + SetNextWindowFocus(); + } + KeepNavHighlight(); + + PushStyleColor(ImGuiCol_WindowBg, AlphaScale(COL_CARD_BG, open_alpha)); + PushStyleColor(ImGuiCol_Border, AlphaScale(COL_SEPARATOR, open_alpha)); + PushStyleColor(ImGuiCol_Text, AlphaScale(COL_TEXT_PRIMARY, open_alpha)); + PushStyleColor(ImGuiCol_Button, AlphaScale(COL_BUTTON_NORMAL, open_alpha)); + PushStyleColor(ImGuiCol_ButtonHovered, AlphaScale(COL_BUTTON_HOVERED, open_alpha)); + PushStyleColor(ImGuiCol_ButtonActive, AlphaScale(COL_BUTTON_ACTIVE, open_alpha)); + PushStyleVar(ImGuiStyleVar_WindowPadding, {0.0f, 0.0f}); + PushStyleVar(ImGuiStyleVar_WindowRounding, 6.0f); + PushStyleVar(ImGuiStyleVar_FrameRounding, 4.0f); + PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f); + + if (Begin("##NpProfileDialog", nullptr, + ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoSavedSettings | + ImGuiWindowFlags_NoMove)) { + + ImDrawList* dl = GetWindowDrawList(); + const ImVec2 win_pos = GetWindowPos(); + + DrawCardShadow(dl, card_min, card_max, open_alpha); + + const ImVec2 hdr_min = win_pos; + const ImVec2 hdr_max = {win_pos.x + CARD_WIDTH, win_pos.y + HEADER_HEIGHT}; + dl->AddRectFilledMultiColor(hdr_min, hdr_max, AlphaScale(COL_HEADER_TOP, open_alpha), + AlphaScale(COL_HEADER_TOP, open_alpha), + AlphaScale(COL_HEADER_BOT, open_alpha), + AlphaScale(COL_HEADER_BOT, open_alpha)); + dl->AddRectFilled({hdr_min.x, hdr_max.y - 6.0f}, hdr_max, + AlphaScale(COL_HEADER_BOT, open_alpha)); + + dl->AddLine({hdr_min.x + 6.0f, hdr_min.y + 1.0f}, {hdr_max.x - 6.0f, hdr_min.y + 1.0f}, + IM_COL32(255, 255, 255, (int)(open_alpha * 40.0f)), 1.0f); + + // Footer separator + const float footer_top_screen = win_pos.y + CARD_HEIGHT - FOOTER_HEIGHT; + dl->AddLine({win_pos.x, footer_top_screen}, {win_pos.x + CARD_WIDTH, footer_top_screen}, + AlphaScale(COL_SEPARATOR, open_alpha), 1.0f); + + // Avatar + const ImVec2 avatar_screen = {win_pos.x + AVATAR_REL_X, win_pos.y + AVATAR_REL_Y}; + DrawAvatarPlaceholder(dl, avatar_screen, AVATAR_RADIUS, open_alpha); + + // Header title + const char* title = GetModeTitle(state->mode); + const ImVec2 title_sz = CalcTextSize(title); + SetCursorPos({(CARD_WIDTH - title_sz.x) * 0.5f, (HEADER_HEIGHT - title_sz.y) * 0.5f}); + TextUnformatted(title); + + // Online ID / Account ID + char id_buf[32]{}; + const char* id_str = state->onlineId.c_str(); + if (state->hasAccountId) { + snprintf(id_buf, sizeof(id_buf), "%" PRIu64, state->accountId); + id_str = id_buf; + } + const float id_y = AVATAR_REL_Y + AVATAR_RADIUS + 14.0f; + const ImVec2 id_sz = CalcTextSize(id_str); + SetCursorPos({(CARD_WIDTH - id_sz.x) * 0.5f, id_y}); + TextUnformatted(id_str); + + // Mode subtitle + PushStyleColor(ImGuiCol_Text, AlphaScale(COL_TEXT_SECONDARY, open_alpha)); + const char* subtitle = GetModeSubtitle(state->mode); + const ImVec2 sub_sz = CalcTextSize(subtitle); + SetCursorPos({(CARD_WIDTH - sub_sz.x) * 0.5f, id_y + id_sz.y + 5.0f}); + TextUnformatted(subtitle); + PopStyleColor(); + + const float footer_y_local = CARD_HEIGHT - FOOTER_HEIGHT; + + PushStyleColor(ImGuiCol_Border, AlphaScale(COL_BUTTON_BORDER, open_alpha)); + PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f); + SetCursorPos({CARD_WIDTH - CLOSE_BUTTON_SIZE.x - 16.0f, + footer_y_local + (FOOTER_HEIGHT - CLOSE_BUTTON_SIZE.y) * 0.5f}); + if (Button("Close##btn", CLOSE_BUTTON_SIZE)) { + Finish(Result::USER_CANCELED); + } + PopStyleVar(); + PopStyleColor(); + + if (first_render) { + SetItemCurrentNavFocus(); + } + } + End(); + + PopStyleVar(4); + PopStyleColor(6); + + first_render = false; +} + +} // namespace Libraries::Np::NpProfileDialog diff --git a/src/core/libraries/np/np_profile_dialog/np_profile_dialog_ui.h b/src/core/libraries/np/np_profile_dialog/np_profile_dialog_ui.h new file mode 100644 index 00000000000..6206ca066df --- /dev/null +++ b/src/core/libraries/np/np_profile_dialog/np_profile_dialog_ui.h @@ -0,0 +1,47 @@ +// SPDX-FileCopyrightText: Copyright 2026 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include "common/fixed_value.h" +#include "common/types.h" +#include "core/libraries/system/commondialog.h" +#include "imgui/imgui_layer.h" +#include "np_profile_dialog.h" + +namespace Libraries::Np::NpProfileDialog { + +struct NpProfileDialogState { + std::string onlineId; + OrbisNpAccountId accountId{}; + bool hasAccountId{false}; + OrbisNpProfileDialogMode mode{OrbisNpProfileDialogMode::ORBIS_NP_PROFILE_DIALOG_MODE_INVALID}; + int userId{}; +}; + +class NpProfileDialogUi : public ImGui::Layer { +public: + explicit NpProfileDialogUi(NpProfileDialogState* state = nullptr, + CommonDialog::Status* status = nullptr, + OrbisNpProfileDialogResult* result = nullptr); + ~NpProfileDialogUi() override; + + NpProfileDialogUi(const NpProfileDialogUi& other) = delete; + NpProfileDialogUi(NpProfileDialogUi&& other) noexcept; + NpProfileDialogUi& operator=(NpProfileDialogUi other); + + void Finish(CommonDialog::Result user_action); + + void Draw() override; + +private: + NpProfileDialogState* state{}; + CommonDialog::Status* status{}; + OrbisNpProfileDialogResult* result{}; + bool first_render{false}; + float open_alpha{0.0f}; +}; + +} // namespace Libraries::Np::NpProfileDialog diff --git a/src/core/libraries/np/np_score.cpp b/src/core/libraries/np/np_score.cpp index 49bb956b207..1c4fbe01557 100644 --- a/src/core/libraries/np/np_score.cpp +++ b/src/core/libraries/np/np_score.cpp @@ -1,4 +1,4 @@ -// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project +// SPDX-FileCopyrightText: Copyright 2025-2026 shadPS4 Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #include "common/logging/log.h" @@ -8,153 +8,345 @@ namespace Libraries::Np::NpScore { -int PS4_SYSV_ABI sceNpScoreAbortRequest() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} +// Helper macro to format pointer safely +#define PTR(ptr) static_cast(ptr) -int PS4_SYSV_ABI sceNpScoreCensorComment() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreAbortRequest(s32 reqId) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called reqId={}", reqId); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreCensorCommentAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreCensorComment(s32 reqId, const char* comment, void* option) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called reqId={}, comment={}, option={}", reqId, + comment ? comment : "null", PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreChangeModeForOtherSaveDataOwners() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNpScoreCreateNpTitleCtx() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreCensorCommentAsync(s32 reqId, const char* comment, void* option) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called reqId={}, comment={}, option={}", reqId, + comment ? comment : "null", PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreCreateNpTitleCtxA() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNpScoreCreateRequest() { +int PS4_SYSV_ABI sceNpScoreChangeModeForOtherSaveDataOwners() { LOG_ERROR(Lib_NpScore, "(STUBBED) called"); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreCreateTitleCtx() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreCreateNpTitleCtx(OrbisNpServiceLabel serviceLabel, OrbisNpId* npId) { + LOG_ERROR(Lib_NpScore, "serviceLabel = {}, npId->data = {}", serviceLabel, npId->handle.data); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreDeleteNpTitleCtx() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreCreateRequest(s32 titleCtxId) { + LOG_ERROR(Lib_NpScore, "libCtxId = {}", titleCtxId); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreDeleteRequest() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreDeleteRequest(s32 reqId) { + LOG_ERROR(Lib_NpScore, "requestId = {:#x}", reqId); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetBoardInfo() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreCreateNpTitleCtxA(OrbisNpServiceLabel npServiceLabel, + UserService::OrbisUserServiceUserId selfId) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called npServiceLabel={}, selfId={}", + static_cast(npServiceLabel), selfId); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetBoardInfoAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNpScoreGetFriendsRanking() { +int PS4_SYSV_ABI sceNpScoreCreateTitleCtx() { LOG_ERROR(Lib_NpScore, "(STUBBED) called"); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetFriendsRankingA() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreDeleteNpTitleCtx(s32 titleCtxId) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called titleCtxId={}", titleCtxId); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetFriendsRankingAAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetBoardInfo(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreBoardInfo* boardInfo, void* option) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called reqId={}, boardId={}, boardInfo={}, option={}", reqId, + boardId, PTR(boardInfo), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetFriendsRankingAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetBoardInfoAsync(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreBoardInfo* boardInfo, void* option) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called reqId={}, boardId={}, boardInfo={}, option={}", reqId, + boardId, PTR(boardInfo), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetFriendsRankingForCrossSave() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetFriendsRanking(s32 reqId, OrbisNpScoreBoardId boardId, + s32 includeSelf, OrbisNpScoreRankData* rankArray, + u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, includeSelf={}, " + "rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, infoArray={}, " + "infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, includeSelf, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetFriendsRankingForCrossSaveAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} +int PS4_SYSV_ABI sceNpScoreGetRankingByRange( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankData* rankArray, u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, "called reqId={}, boardId={}, startSerialRank={}, arrayNum={}", reqId, + boardId, startSerialRank, arrayNum); -int PS4_SYSV_ABI sceNpScoreGetGameData() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetGameDataAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetFriendsRankingA(s32 reqId, OrbisNpScoreBoardId boardId, + s32 includeSelf, OrbisNpScoreRankDataA* rankArray, + u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, + OrbisNpScoreGetFriendRankingOptParam* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, includeSelf={}, " + "rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, infoArray={}, " + "infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, includeSelf, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetGameDataByAccountId() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetFriendsRankingAAsync( + s32 reqId, OrbisNpScoreBoardId boardId, s32 includeSelf, OrbisNpScoreRankDataA* rankArray, + u64 rankArraySize, OrbisNpScoreComment* commentArray, u64 commentArraySize, + OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, + OrbisNpScoreGetFriendRankingOptParam* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, includeSelf={}, " + "rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, infoArray={}, " + "infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, includeSelf, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetGameDataByAccountIdAsync() { +int PS4_SYSV_ABI sceNpScoreGetFriendsRankingAsync( + s32 reqId, OrbisNpScoreBoardId boardId, s32 includeSelf, OrbisNpScoreRankData* rankArray, + u64 rankArraySize, OrbisNpScoreComment* commentArray, u64 commentArraySize, + OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, + OrbisNpScoreGetFriendRankingOptParam* option) { LOG_ERROR(Lib_NpScore, "(STUBBED) called"); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountId() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetFriendsRankingForCrossSave( + s32 reqId, OrbisNpScoreBoardId boardId, s32 includeSelf, + OrbisNpScoreRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, OrbisNpScoreGetFriendRankingOptParam* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, includeSelf={}, " + "rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, infoArray={}, " + "infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, includeSelf, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetFriendsRankingForCrossSaveAsync( + s32 reqId, OrbisNpScoreBoardId boardId, s32 includeSelf, + OrbisNpScoreRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, OrbisNpScoreGetFriendRankingOptParam* option) { + LOG_ERROR( + Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, " + "includeSelf={}, rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, " + "infoArray={}, infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, includeSelf, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdForCrossSave() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdForCrossSaveAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcId() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdAsync() { +int PS4_SYSV_ABI sceNpScoreGetGameData() { LOG_ERROR(Lib_NpScore, "(STUBBED) called"); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdForCrossSave() { +int PS4_SYSV_ABI sceNpScoreGetGameDataAsync() { LOG_ERROR(Lib_NpScore, "(STUBBED) called"); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdForCrossSaveAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetGameDataByAccountId(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpAccountId accountId, u64* totalSize, + u64 recvSize, void* data, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, accountId={}, " + "totalSize={}, recvSize={}, data={}, option={}", + reqId, boardId, accountId, PTR(totalSize), recvSize, PTR(data), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetGameDataByAccountIdAsync(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpAccountId accountId, u64* totalSize, + u64 recvSize, void* data, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, accountId={}, " + "totalSize={}, recvSize={}, data={}, option={}", + reqId, boardId, accountId, PTR(totalSize), recvSize, PTR(data), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountId( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpAccountId* accountIdArray, + u64 accountIdArraySize, OrbisNpScorePlayerRankDataA* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, accountIdArray={}, " + "accountIdArraySize={}, rankArray={}, rankArraySize={}, commentArray={}, " + "commentArraySize={}, infoArray={}, infoArraySize={}, arrayNum={}, lastSortDate={}, " + "totalRecord={}, option={}", + reqId, boardId, PTR(accountIdArray), accountIdArraySize, PTR(rankArray), + rankArraySize, PTR(commentArray), commentArraySize, PTR(infoArray), infoArraySize, + arrayNum, PTR(lastSortDate), PTR(totalRecord), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdAsync( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpAccountId* accountIdArray, + u64 accountIdArraySize, OrbisNpScorePlayerRankDataA* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, " + "accountIdArray={}, accountIdArraySize={}, rankArray={}, rankArraySize={}, " + "commentArray={}, commentArraySize={}, infoArray={}, infoArraySize={}, arrayNum={}, " + "lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, PTR(accountIdArray), accountIdArraySize, PTR(rankArray), + rankArraySize, PTR(commentArray), commentArraySize, PTR(infoArray), infoArraySize, + arrayNum, PTR(lastSortDate), PTR(totalRecord), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdForCrossSave( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpAccountId* accountIdArray, + u64 accountIdArraySize, OrbisNpScorePlayerRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, " + "accountIdArray={}, accountIdArraySize={}, rankArray={}, rankArraySize={}, " + "commentArray={}, commentArraySize={}, infoArray={}, infoArraySize={}, arrayNum={}, " + "lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, PTR(accountIdArray), accountIdArraySize, PTR(rankArray), + rankArraySize, PTR(commentArray), commentArraySize, PTR(infoArray), infoArraySize, + arrayNum, PTR(lastSortDate), PTR(totalRecord), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdForCrossSaveAsync( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpAccountId* accountIdArray, + u64 accountIdArraySize, OrbisNpScorePlayerRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, " + "accountIdArray={}, accountIdArraySize={}, rankArray={}, rankArraySize={}, " + "commentArray={}, commentArraySize={}, infoArray={}, infoArraySize={}, arrayNum={}, " + "lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, PTR(accountIdArray), accountIdArraySize, PTR(rankArray), + rankArraySize, PTR(commentArray), commentArraySize, PTR(infoArray), infoArraySize, + arrayNum, PTR(lastSortDate), PTR(totalRecord), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcId( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpScoreAccountIdPcId* idArray, + u64 idArraySize, OrbisNpScorePlayerRankDataA* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR( + Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, idArray={}, " + "idArraySize={}, rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, " + "infoArray={}, infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, PTR(idArray), idArraySize, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdAsync( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpScoreAccountIdPcId* idArray, + u64 idArraySize, OrbisNpScorePlayerRankDataA* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR( + Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, idArray={}, " + "idArraySize={}, rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, " + "infoArray={}, infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, PTR(idArray), idArraySize, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdForCrossSave( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpScoreAccountIdPcId* idArray, + u64 idArraySize, OrbisNpScorePlayerRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, " + "idArray={}, idArraySize={}, rankArray={}, rankArraySize={}, commentArray={}, " + "commentArraySize={}, infoArray={}, infoArraySize={}, arrayNum={}, lastSortDate={}, " + "totalRecord={}, option={}", + reqId, boardId, PTR(idArray), idArraySize, PTR(rankArray), rankArraySize, + PTR(commentArray), commentArraySize, PTR(infoArray), infoArraySize, arrayNum, + PTR(lastSortDate), PTR(totalRecord), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdForCrossSaveAsync( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpScoreAccountIdPcId* idArray, + u64 idArraySize, OrbisNpScorePlayerRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, " + "idArray={}, idArraySize={}, rankArray={}, rankArraySize={}, commentArray={}, " + "commentArraySize={}, infoArray={}, infoArraySize={}, arrayNum={}, lastSortDate={}, " + "totalRecord={}, option={}", + reqId, boardId, PTR(idArray), idArraySize, PTR(rankArray), rankArraySize, + PTR(commentArray), commentArraySize, PTR(infoArray), infoArraySize, arrayNum, + PTR(lastSortDate), PTR(totalRecord), PTR(option)); return ORBIS_OK; } @@ -178,88 +370,177 @@ int PS4_SYSV_ABI sceNpScoreGetRankingByNpIdPcIdAsync() { return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetRankingByRange() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNpScoreGetRankingByRangeA() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNpScoreGetRankingByRangeAAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNpScoreGetRankingByRangeAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetRankingByRangeA( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankDataA* rankArray, u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, startSerialRank={}, " + "rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, infoArray={}, " + "infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, startSerialRank, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetRankingByRangeAAsync( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankDataA* rankArray, u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, startSerialRank={}, " + "rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, infoArray={}, " + "infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, startSerialRank, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNpScoreGetRankingByRangeAsync( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankData* rankArray, u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, startSerialRank={}, " + "rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, infoArray={}, " + "infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, startSerialRank, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetRankingByRangeForCrossSave() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetRankingByRangeForCrossSave( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR( + Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, " + "startSerialRank={}, rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, " + "infoArray={}, infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, startSerialRank, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreGetRankingByRangeForCrossSaveAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreGetRankingByRangeForCrossSaveAsync( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option) { + LOG_ERROR( + Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, " + "startSerialRank={}, rankArray={}, rankArraySize={}, commentArray={}, commentArraySize={}, " + "infoArray={}, infoArraySize={}, arrayNum={}, lastSortDate={}, totalRecord={}, option={}", + reqId, boardId, startSerialRank, PTR(rankArray), rankArraySize, PTR(commentArray), + commentArraySize, PTR(infoArray), infoArraySize, arrayNum, PTR(lastSortDate), + PTR(totalRecord), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScorePollAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScorePollAsync(s32 reqId, s32* result) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called reqId={}, result={}", reqId, PTR(result)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreRecordGameData() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreRecordGameData(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreValue score, u64 totalSize, u64 sendSize, + const void* data, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, score={}, totalSize={}, " + "sendSize={}, data={}, option={}", + reqId, boardId, score, totalSize, sendSize, PTR(data), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreRecordGameDataAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreRecordGameDataAsync(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreValue score, u64 totalSize, u64 sendSize, + const void* data, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, score={}, " + "totalSize={}, sendSize={}, data={}, option={}", + reqId, boardId, score, totalSize, sendSize, PTR(data), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreRecordScore() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreRecordScore(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreValue score, + const OrbisNpScoreComment* scoreComment, + const OrbisNpScoreGameInfo* gameInfo, + OrbisNpScoreRankNumber* tmpRank, + const Rtc::OrbisRtcTick* compareDate, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, score={}, scoreComment={}, " + "gameInfo={}, tmpRank={}, compareDate={}, option={}", + reqId, boardId, score, PTR(scoreComment), PTR(gameInfo), PTR(tmpRank), + PTR(compareDate), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreRecordScoreAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreRecordScoreAsync(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreValue score, + const OrbisNpScoreComment* scoreComment, + const OrbisNpScoreGameInfo* gameInfo, + OrbisNpScoreRankNumber* tmpRank, + const Rtc::OrbisRtcTick* compareDate, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, boardId={}, score={}, " + "scoreComment={}, gameInfo={}, tmpRank={}, compareDate={}, option={}", + reqId, boardId, score, PTR(scoreComment), PTR(gameInfo), PTR(tmpRank), + PTR(compareDate), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreSanitizeComment() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreSanitizeComment(s32 reqId, const char* comment, char* sanitizedComment, + void* option) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called reqId={}, comment={}, sanitizedComment={}, option={}", + reqId, comment ? comment : "null", PTR(sanitizedComment), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreSanitizeCommentAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreSanitizeCommentAsync(s32 reqId, const char* comment, + char* sanitizedComment, void* option) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called reqId={}, comment={}, sanitizedComment={}, " + "option={}", + reqId, comment ? comment : "null", PTR(sanitizedComment), PTR(option)); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreSetPlayerCharacterId() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreSetPlayerCharacterId(s32 ctxId, OrbisNpScorePcId pcId) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called ctxId={}, pcId={}", ctxId, pcId); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreSetThreadParam() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreSetThreadParam(s32 threadPriority, u64 cpuAffinityMask) { + LOG_ERROR(Lib_NpScore, "(STUBBED) called threadPriority={}, cpuAffinityMask={:#x}", + threadPriority, cpuAffinityMask); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreSetTimeout() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreSetTimeout(s32 id, s32 resolveRetry, s32 resolveTimeout, s32 connTimeout, + s32 sendTimeout, s32 recvTimeout) { + LOG_ERROR(Lib_NpScore, + "(STUBBED) called id={}, resolveRetry={}, resolveTimeout={}, " + "connTimeout={}, sendTimeout={}, recvTimeout={}", + id, resolveRetry, resolveTimeout, connTimeout, sendTimeout, recvTimeout); return ORBIS_OK; } -int PS4_SYSV_ABI sceNpScoreWaitAsync() { - LOG_ERROR(Lib_NpScore, "(STUBBED) called"); +int PS4_SYSV_ABI sceNpScoreWaitAsync(s32 reqId, s32* result) { + LOG_ERROR(Lib_NpScore, "(STUBBED) sceNpScoreWaitAsync(reqId={}, result={})", reqId, + PTR(result)); return ORBIS_OK; } diff --git a/src/core/libraries/np/np_score.h b/src/core/libraries/np/np_score.h index 01cc25f2ff8..0705707b699 100644 --- a/src/core/libraries/np/np_score.h +++ b/src/core/libraries/np/np_score.h @@ -1,9 +1,12 @@ -// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project +// SPDX-FileCopyrightText: Copyright 2025-2026 shadPS4 Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once #include "common/types.h" +#include "core/libraries/np/np_types.h" +#include "core/libraries/rtc/rtc.h" +#include "core/libraries/system/userservice.h" namespace Core::Loader { class SymbolsResolver; @@ -11,57 +14,283 @@ class SymbolsResolver; namespace Libraries::Np::NpScore { -int PS4_SYSV_ABI sceNpScoreAbortRequest(); -int PS4_SYSV_ABI sceNpScoreCensorComment(); -int PS4_SYSV_ABI sceNpScoreCensorCommentAsync(); +using OrbisNpScoreBoardId = u32; +using OrbisNpScorePcId = s32; +using OrbisNpScoreRankNumber = u32; +using OrbisNpScoreValue = s64; + +constexpr int ORBIS_NP_SCORE_COMMENT_MAXLEN = 63; +constexpr int ORBIS_NP_SCORE_GAMEINFO_MAXSIZE = 189; + +struct OrbisNpScoreBoardInfo { + u32 rankLimit; + u32 updateMode; + u32 sortMode; + OrbisNpScoreRankNumber uploadNumLimit; + u64 uploadSizeLimit; +}; + +struct OrbisNpScoreComment { + char utf8Comment[ORBIS_NP_SCORE_COMMENT_MAXLEN + 1]; +}; + +struct OrbisNpScoreGameInfo { + u64 infoSize; + u8 data[ORBIS_NP_SCORE_GAMEINFO_MAXSIZE]; + u8 pad2[3]; +}; + +struct OrbisNpScoreGetFriendRankingOptParam { + u64 size; + u32* startSerialRank; + u32* hits; +}; + +struct OrbisNpScoreAccountIdPcId { + OrbisNpAccountId accountId; + OrbisNpScorePcId pcId; + u8 pad[4]; +}; + +struct OrbisNpScoreNpIdPcId { + OrbisNpId npId; + OrbisNpScorePcId pcId; + u8 pad[4]; +}; + +struct OrbisNpScoreRankData { + OrbisNpId npId; + u8 reserved[49]; + u8 pad0[3]; + OrbisNpScorePcId pcId; + OrbisNpScoreRankNumber serialRank; + OrbisNpScoreRankNumber rank; + OrbisNpScoreRankNumber highestRank; + s32 hasGameData; + u8 pad1[4]; + OrbisNpScoreValue scoreValue; + Rtc::OrbisRtcTick recordDate; +}; + +struct OrbisNpScoreRankDataA { + OrbisNpOnlineId onlineId; + u8 reserved0[16]; + u8 reserved[49]; + u8 pad0[3]; + OrbisNpScorePcId pcId; + OrbisNpScoreRankNumber serialRank; + OrbisNpScoreRankNumber rank; + OrbisNpScoreRankNumber highestRank; + s32 hasGameData; + u8 pad1[4]; + OrbisNpScoreValue scoreValue; + Rtc::OrbisRtcTick recordDate; + OrbisNpAccountId accountId; + u8 pad2[8]; +}; + +struct OrbisNpScorePlayerRankDataA { + s32 hasData; + u8 pad0[4]; + OrbisNpScoreRankDataA rankData; +}; + +struct OrbisNpScoreRankDataForCrossSave { + OrbisNpId npId; + u8 reserved[49]; + u8 pad0[3]; + OrbisNpScorePcId pcId; + OrbisNpScoreRankNumber serialRank; + OrbisNpScoreRankNumber rank; + OrbisNpScoreRankNumber highestRank; + s32 hasGameData; + u8 pad1[4]; + OrbisNpScoreValue scoreValue; + Rtc::OrbisRtcTick recordDate; + OrbisNpAccountId accountId; + u8 pad2[8]; +}; + +struct OrbisNpScorePlayerRankDataForCrossSave { + s32 hasData; + u8 pad0[4]; + OrbisNpScoreRankDataForCrossSave rankData; +}; +int PS4_SYSV_ABI sceNpScoreCreateNpTitleCtx(OrbisNpServiceLabel serviceLabel, OrbisNpId* npId); +// stubbed +int PS4_SYSV_ABI sceNpScoreAbortRequest(s32 reqId); +int PS4_SYSV_ABI sceNpScoreCensorComment(s32 reqId, const char* comment, void* option); +int PS4_SYSV_ABI sceNpScoreCensorCommentAsync(s32 reqId, const char* comment, void* option); int PS4_SYSV_ABI sceNpScoreChangeModeForOtherSaveDataOwners(); -int PS4_SYSV_ABI sceNpScoreCreateNpTitleCtx(); -int PS4_SYSV_ABI sceNpScoreCreateNpTitleCtxA(); -int PS4_SYSV_ABI sceNpScoreCreateRequest(); +int PS4_SYSV_ABI sceNpScoreCreateNpTitleCtxA(OrbisNpServiceLabel npServiceLabel, + UserService::OrbisUserServiceUserId selfId); +int PS4_SYSV_ABI sceNpScoreCreateRequest(s32 titleCtxId); int PS4_SYSV_ABI sceNpScoreCreateTitleCtx(); -int PS4_SYSV_ABI sceNpScoreDeleteNpTitleCtx(); -int PS4_SYSV_ABI sceNpScoreDeleteRequest(); -int PS4_SYSV_ABI sceNpScoreGetBoardInfo(); -int PS4_SYSV_ABI sceNpScoreGetBoardInfoAsync(); -int PS4_SYSV_ABI sceNpScoreGetFriendsRanking(); -int PS4_SYSV_ABI sceNpScoreGetFriendsRankingA(); -int PS4_SYSV_ABI sceNpScoreGetFriendsRankingAAsync(); -int PS4_SYSV_ABI sceNpScoreGetFriendsRankingAsync(); -int PS4_SYSV_ABI sceNpScoreGetFriendsRankingForCrossSave(); -int PS4_SYSV_ABI sceNpScoreGetFriendsRankingForCrossSaveAsync(); +int PS4_SYSV_ABI sceNpScoreDeleteNpTitleCtx(s32 titleCtxId); +int PS4_SYSV_ABI sceNpScoreDeleteRequest(s32 reqId); +int PS4_SYSV_ABI sceNpScoreGetBoardInfo(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreBoardInfo* boardInfo, void* option); +int PS4_SYSV_ABI sceNpScoreGetBoardInfoAsync(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreBoardInfo* boardInfo, void* option); +int PS4_SYSV_ABI sceNpScoreGetFriendsRanking(s32 reqId, OrbisNpScoreBoardId boardId, + s32 includeSelf, OrbisNpScoreRankData* rankArray, + u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetFriendsRankingA(s32 reqId, OrbisNpScoreBoardId boardId, + s32 includeSelf, OrbisNpScoreRankDataA* rankArray, + u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, + OrbisNpScoreGetFriendRankingOptParam* option); +int PS4_SYSV_ABI sceNpScoreGetFriendsRankingAAsync( + s32 reqId, OrbisNpScoreBoardId boardId, s32 includeSelf, OrbisNpScoreRankDataA* rankArray, + u64 rankArraySize, OrbisNpScoreComment* commentArray, u64 commentArraySize, + OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, + OrbisNpScoreGetFriendRankingOptParam* option); +int PS4_SYSV_ABI sceNpScoreGetFriendsRankingAsync( + s32 reqId, OrbisNpScoreBoardId boardId, s32 includeSelf, OrbisNpScoreRankData* rankArray, + u64 rankArraySize, OrbisNpScoreComment* commentArray, u64 commentArraySize, + OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, + OrbisNpScoreGetFriendRankingOptParam* option); +int PS4_SYSV_ABI sceNpScoreGetFriendsRankingForCrossSave( + s32 reqId, OrbisNpScoreBoardId boardId, s32 includeSelf, + OrbisNpScoreRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, OrbisNpScoreGetFriendRankingOptParam* option); +int PS4_SYSV_ABI sceNpScoreGetFriendsRankingForCrossSaveAsync( + s32 reqId, OrbisNpScoreBoardId boardId, s32 includeSelf, + OrbisNpScoreRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, OrbisNpScoreGetFriendRankingOptParam* option); int PS4_SYSV_ABI sceNpScoreGetGameData(); int PS4_SYSV_ABI sceNpScoreGetGameDataAsync(); -int PS4_SYSV_ABI sceNpScoreGetGameDataByAccountId(); -int PS4_SYSV_ABI sceNpScoreGetGameDataByAccountIdAsync(); -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountId(); -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdAsync(); -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdForCrossSave(); -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdForCrossSaveAsync(); -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcId(); -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdAsync(); -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdForCrossSave(); -int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdForCrossSaveAsync(); +int PS4_SYSV_ABI sceNpScoreGetGameDataByAccountId(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpAccountId accountId, u64* totalSize, + u64 recvSize, void* data, void* option); +int PS4_SYSV_ABI sceNpScoreGetGameDataByAccountIdAsync(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpAccountId accountId, u64* totalSize, + u64 recvSize, void* data, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountId( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpAccountId* accountIdArray, + u64 accountIdArraySize, OrbisNpScorePlayerRankDataA* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdAsync( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpAccountId* accountIdArray, + u64 accountIdArraySize, OrbisNpScorePlayerRankDataA* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdForCrossSave( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpAccountId* accountIdArray, + u64 accountIdArraySize, OrbisNpScorePlayerRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdForCrossSaveAsync( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpAccountId* accountIdArray, + u64 accountIdArraySize, OrbisNpScorePlayerRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcId( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpScoreAccountIdPcId* idArray, + u64 idArraySize, OrbisNpScorePlayerRankDataA* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdAsync( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpScoreAccountIdPcId* idArray, + u64 idArraySize, OrbisNpScorePlayerRankDataA* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdForCrossSave( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpScoreAccountIdPcId* idArray, + u64 idArraySize, OrbisNpScorePlayerRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdForCrossSaveAsync( + s32 reqId, OrbisNpScoreBoardId boardId, const OrbisNpScoreAccountIdPcId* idArray, + u64 idArraySize, OrbisNpScorePlayerRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); int PS4_SYSV_ABI sceNpScoreGetRankingByNpId(); int PS4_SYSV_ABI sceNpScoreGetRankingByNpIdAsync(); int PS4_SYSV_ABI sceNpScoreGetRankingByNpIdPcId(); int PS4_SYSV_ABI sceNpScoreGetRankingByNpIdPcIdAsync(); -int PS4_SYSV_ABI sceNpScoreGetRankingByRange(); -int PS4_SYSV_ABI sceNpScoreGetRankingByRangeA(); -int PS4_SYSV_ABI sceNpScoreGetRankingByRangeAAsync(); -int PS4_SYSV_ABI sceNpScoreGetRankingByRangeAsync(); -int PS4_SYSV_ABI sceNpScoreGetRankingByRangeForCrossSave(); -int PS4_SYSV_ABI sceNpScoreGetRankingByRangeForCrossSaveAsync(); -int PS4_SYSV_ABI sceNpScorePollAsync(); -int PS4_SYSV_ABI sceNpScoreRecordGameData(); -int PS4_SYSV_ABI sceNpScoreRecordGameDataAsync(); -int PS4_SYSV_ABI sceNpScoreRecordScore(); -int PS4_SYSV_ABI sceNpScoreRecordScoreAsync(); -int PS4_SYSV_ABI sceNpScoreSanitizeComment(); -int PS4_SYSV_ABI sceNpScoreSanitizeCommentAsync(); -int PS4_SYSV_ABI sceNpScoreSetPlayerCharacterId(); -int PS4_SYSV_ABI sceNpScoreSetThreadParam(); -int PS4_SYSV_ABI sceNpScoreSetTimeout(); -int PS4_SYSV_ABI sceNpScoreWaitAsync(); +int PS4_SYSV_ABI sceNpScoreGetRankingByRange( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankData* rankArray, u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByRangeA( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankDataA* rankArray, u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByRangeAAsync( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankDataA* rankArray, u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByRangeAsync( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankData* rankArray, u64 rankArraySize, OrbisNpScoreComment* commentArray, + u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, u64 infoArraySize, u64 arrayNum, + Rtc::OrbisRtcTick* lastSortDate, OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByRangeForCrossSave( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScoreGetRankingByRangeForCrossSaveAsync( + s32 reqId, OrbisNpScoreBoardId boardId, OrbisNpScoreRankNumber startSerialRank, + OrbisNpScoreRankDataForCrossSave* rankArray, u64 rankArraySize, + OrbisNpScoreComment* commentArray, u64 commentArraySize, OrbisNpScoreGameInfo* infoArray, + u64 infoArraySize, u64 arrayNum, Rtc::OrbisRtcTick* lastSortDate, + OrbisNpScoreRankNumber* totalRecord, void* option); +int PS4_SYSV_ABI sceNpScorePollAsync(s32 reqId, s32* result); +int PS4_SYSV_ABI sceNpScoreRecordGameData(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreValue score, u64 totalSize, u64 sendSize, + const void* data, void* option); +int PS4_SYSV_ABI sceNpScoreRecordGameDataAsync(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreValue score, u64 totalSize, u64 sendSize, + const void* data, void* option); +int PS4_SYSV_ABI sceNpScoreRecordScore(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreValue score, + const OrbisNpScoreComment* scoreComment, + const OrbisNpScoreGameInfo* gameInfo, + OrbisNpScoreRankNumber* tmpRank, + const Rtc::OrbisRtcTick* compareDate, void* option); +int PS4_SYSV_ABI sceNpScoreRecordScoreAsync(s32 reqId, OrbisNpScoreBoardId boardId, + OrbisNpScoreValue score, + const OrbisNpScoreComment* scoreComment, + const OrbisNpScoreGameInfo* gameInfo, + OrbisNpScoreRankNumber* tmpRank, + const Rtc::OrbisRtcTick* compareDate, void* option); +int PS4_SYSV_ABI sceNpScoreSanitizeComment(s32 reqId, const char* comment, char* sanitizedComment, + void* option); +int PS4_SYSV_ABI sceNpScoreSanitizeCommentAsync(s32 reqId, const char* comment, + char* sanitizedComment, void* option); +int PS4_SYSV_ABI sceNpScoreSetPlayerCharacterId(s32 ctxId, OrbisNpScorePcId pcId); +int PS4_SYSV_ABI sceNpScoreSetThreadParam(s32 threadPriority, u64 cpuAffinityMask); +int PS4_SYSV_ABI sceNpScoreSetTimeout(s32 id, s32 resolveRetry, s32 resolveTimeout, s32 connTimeout, + s32 sendTimeout, s32 recvTimeout); +int PS4_SYSV_ABI sceNpScoreWaitAsync(s32 reqId, s32* result); void RegisterLib(Core::Loader::SymbolsResolver* sym); -} // namespace Libraries::Np::NpScore \ No newline at end of file +} // namespace Libraries::Np::NpScore diff --git a/src/core/libraries/web_browser_dialog/webbrowserdialog.cpp b/src/core/libraries/web_browser_dialog/webbrowserdialog.cpp index 5844affa2e5..4c39a69d632 100644 --- a/src/core/libraries/web_browser_dialog/webbrowserdialog.cpp +++ b/src/core/libraries/web_browser_dialog/webbrowserdialog.cpp @@ -1,4 +1,4 @@ -// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-FileCopyrightText: Copyright 2024-2026 shadPS4 Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #include "common/logging/log.h" @@ -11,9 +11,13 @@ namespace Libraries::WebBrowserDialog { static auto g_status = Libraries::CommonDialog::Status::NONE; -s32 PS4_SYSV_ABI sceWebBrowserDialogClose() { +Libraries::CommonDialog::Error PS4_SYSV_ABI sceWebBrowserDialogClose() { LOG_ERROR(Lib_WebBrowserDialog, "(STUBBED) called"); - return ORBIS_OK; + if (g_status != Libraries::CommonDialog::Status::RUNNING) { + return Libraries::CommonDialog::Error::NOT_RUNNING; + } + LOG_INFO(Lib_NpProfileDialog, "TODO: close npprofile ui dialog"); // TODO close Ui dialog + return Libraries::CommonDialog::Error::OK; } s32 PS4_SYSV_ABI sceWebBrowserDialogGetEvent() { @@ -27,17 +31,23 @@ s32 PS4_SYSV_ABI sceWebBrowserDialogGetResult() { } Libraries::CommonDialog::Status PS4_SYSV_ABI sceWebBrowserDialogGetStatus() { - LOG_TRACE(Lib_MsgDlg, "called status={}", magic_enum::enum_name(g_status)); + LOG_TRACE(Lib_WebBrowserDialog, "called status={}", magic_enum::enum_name(g_status)); return g_status; } Libraries::CommonDialog::Error PS4_SYSV_ABI sceWebBrowserDialogInitialize() { - if (CommonDialog::g_isInitialized) { - LOG_INFO(Lib_WebBrowserDialog, "already initialized"); - return Libraries::CommonDialog::Error::ALREADY_SYSTEM_INITIALIZED; + if (!CommonDialog::g_isInitialized) { + return Libraries::CommonDialog::Error::NOT_SYSTEM_INITIALIZED; } - LOG_DEBUG(Lib_WebBrowserDialog, "initialized"); - CommonDialog::g_isInitialized = true; + if (g_status != Libraries::CommonDialog::Status::NONE) { + LOG_ERROR(Lib_WebBrowserDialog, "already initialized"); + return Libraries::CommonDialog::Error::ALREADY_INITIALIZED; + } + if (CommonDialog::g_isUsed) { + return Libraries::CommonDialog::Error::BUSY; + } + g_status = Libraries::CommonDialog::Status::INITIALIZED; + CommonDialog::g_isUsed = true; return Libraries::CommonDialog::Error::OK; } @@ -46,9 +56,15 @@ s32 PS4_SYSV_ABI sceWebBrowserDialogNavigate() { return ORBIS_OK; } -s32 PS4_SYSV_ABI sceWebBrowserDialogOpen() { - LOG_ERROR(Lib_WebBrowserDialog, "(STUBBED) called"); - return ORBIS_OK; +Libraries::CommonDialog::Error PS4_SYSV_ABI sceWebBrowserDialogOpen() { + if (g_status != Libraries::CommonDialog::Status::INITIALIZED && + g_status != Libraries::CommonDialog::Status::FINISHED) { + LOG_INFO(Lib_WebBrowserDialog, "called without initialize"); + return Libraries::CommonDialog::Error::INVALID_STATE; + } + LOG_ERROR(Lib_WebBrowserDialog, "(STUBBED) called"); // TODO open ui dialog + g_status = Libraries::CommonDialog::Status::RUNNING; + return Libraries::CommonDialog::Error::OK; } s32 PS4_SYSV_ABI sceWebBrowserDialogOpenForPredeterminedContent() { @@ -73,8 +89,7 @@ s32 PS4_SYSV_ABI sceWebBrowserDialogSetZoom() { Libraries::CommonDialog::Error PS4_SYSV_ABI sceWebBrowserDialogTerminate() { if (g_status == Libraries::CommonDialog::Status::RUNNING) { - LOG_ERROR(Lib_WebBrowserDialog, - "CloseWebBrowser Dialog unimplemented"); // sceWebBrowserDialogClose(); + sceWebBrowserDialogClose(); } if (g_status == Libraries::CommonDialog::Status::NONE) { return Libraries::CommonDialog::Error::NOT_INITIALIZED; @@ -85,7 +100,11 @@ Libraries::CommonDialog::Error PS4_SYSV_ABI sceWebBrowserDialogTerminate() { } Libraries::CommonDialog::Status PS4_SYSV_ABI sceWebBrowserDialogUpdateStatus() { - LOG_TRACE(Lib_MsgDlg, "called status={}", magic_enum::enum_name(g_status)); + LOG_TRACE(Lib_WebBrowserDialog, "called status={}", magic_enum::enum_name(g_status)); + if (g_status == Libraries::CommonDialog::Status::RUNNING) { + g_status = Libraries::CommonDialog::Status::FINISHED; // TODO removed it when implementing + // real dialog + } return g_status; } diff --git a/src/core/libraries/web_browser_dialog/webbrowserdialog.h b/src/core/libraries/web_browser_dialog/webbrowserdialog.h index 3dad7e1e914..4fac2a3f03d 100644 --- a/src/core/libraries/web_browser_dialog/webbrowserdialog.h +++ b/src/core/libraries/web_browser_dialog/webbrowserdialog.h @@ -1,4 +1,4 @@ -// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-FileCopyrightText: Copyright 2024-2026 shadPS4 Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once @@ -12,13 +12,13 @@ class SymbolsResolver; namespace Libraries::WebBrowserDialog { -s32 PS4_SYSV_ABI sceWebBrowserDialogClose(); +Libraries::CommonDialog::Error PS4_SYSV_ABI sceWebBrowserDialogClose(); s32 PS4_SYSV_ABI sceWebBrowserDialogGetEvent(); s32 PS4_SYSV_ABI sceWebBrowserDialogGetResult(); Libraries::CommonDialog::Status PS4_SYSV_ABI sceWebBrowserDialogGetStatus(); Libraries::CommonDialog::Error PS4_SYSV_ABI sceWebBrowserDialogInitialize(); s32 PS4_SYSV_ABI sceWebBrowserDialogNavigate(); -s32 PS4_SYSV_ABI sceWebBrowserDialogOpen(); +Libraries::CommonDialog::Error PS4_SYSV_ABI sceWebBrowserDialogOpen(); s32 PS4_SYSV_ABI sceWebBrowserDialogOpenForPredeterminedContent(); s32 PS4_SYSV_ABI sceWebBrowserDialogResetCookie(); s32 PS4_SYSV_ABI sceWebBrowserDialogSetCookie();