Compare commits
15 Commits
new-gpu
...
diff-limit
Author | SHA1 | Date | |
---|---|---|---|
c23f367262 | |||
0e4e8aa45a | |||
12880e9170 | |||
f2ee9baec7 | |||
8e2037b3ff | |||
c6bcbc02de | |||
36db566428 | |||
9b147d3f9c | |||
7dd9174d31 | |||
5a7f615da1 | |||
811303ea54 | |||
5bcdcffd96 | |||
2bb7f89c30 | |||
602f4f60d8 | |||
3113ae6616 |
@ -26,16 +26,14 @@ set(HASH_FILES
|
||||
"${VIDEO_CORE}/shader/generator/spv_fs_shader_gen.h"
|
||||
"${VIDEO_CORE}/shader/shader.cpp"
|
||||
"${VIDEO_CORE}/shader/shader.h"
|
||||
"${VIDEO_CORE}/pica.cpp"
|
||||
"${VIDEO_CORE}/pica.h"
|
||||
"${VIDEO_CORE}/regs_framebuffer.h"
|
||||
"${VIDEO_CORE}/regs_lighting.h"
|
||||
"${VIDEO_CORE}/regs_pipeline.h"
|
||||
"${VIDEO_CORE}/regs_rasterizer.h"
|
||||
"${VIDEO_CORE}/regs_shader.h"
|
||||
"${VIDEO_CORE}/regs_texturing.h"
|
||||
"${VIDEO_CORE}/regs.cpp"
|
||||
"${VIDEO_CORE}/regs.h"
|
||||
"${VIDEO_CORE}/pica/regs_framebuffer.h"
|
||||
"${VIDEO_CORE}/pica/regs_lighting.h"
|
||||
"${VIDEO_CORE}/pica/regs_pipeline.h"
|
||||
"${VIDEO_CORE}/pica/regs_rasterizer.h"
|
||||
"${VIDEO_CORE}/pica/regs_shader.h"
|
||||
"${VIDEO_CORE}/pica/regs_texturing.h"
|
||||
"${VIDEO_CORE}/pica/regs_internal.cpp"
|
||||
"${VIDEO_CORE}/pica/regs_internal.h"
|
||||
)
|
||||
set(COMBINED "")
|
||||
foreach (F IN LISTS HASH_FILES)
|
||||
|
32
dist/apple/Info.plist.in
vendored
32
dist/apple/Info.plist.in
vendored
@ -26,6 +26,38 @@
|
||||
<!-- Fixed -->
|
||||
<key>LSApplicationCategoryType</key>
|
||||
<string>public.app-category.games</string>
|
||||
<key>CFBundleDocumentTypes</key>
|
||||
<array>
|
||||
<dict>
|
||||
<key>CFBundleTypeExtensions</key>
|
||||
<array>
|
||||
<string>3ds</string>
|
||||
<string>3dsx</string>
|
||||
<string>cci</string>
|
||||
<string>cxi</string>
|
||||
<string>cia</string>
|
||||
</array>
|
||||
<key>CFBundleTypeName</key>
|
||||
<string>Nintendo 3DS File</string>
|
||||
<key>CFBundleTypeRole</key>
|
||||
<string>Viewer</string>
|
||||
<key>LSHandlerRank</key>
|
||||
<string>Default</string>
|
||||
</dict>
|
||||
<dict>
|
||||
<key>CFBundleTypeExtensions</key>
|
||||
<array>
|
||||
<string>elf</string>
|
||||
<string>axf</string>
|
||||
</array>
|
||||
<key>CFBundleTypeName</key>
|
||||
<string>Unix Executable and Linkable Format</string>
|
||||
<key>CFBundleTypeRole</key>
|
||||
<string>Viewer</string>
|
||||
<key>LSHandlerRank</key>
|
||||
<string>Alternate</string>
|
||||
</dict>
|
||||
</array>
|
||||
<key>NSCameraUsageDescription</key>
|
||||
<string>This app requires camera access to emulate the 3DS's cameras.</string>
|
||||
<key>NSMicrophoneUsageDescription</key>
|
||||
|
@ -7,25 +7,13 @@ package org.citra.citra_emu.features.cheats.model
|
||||
import androidx.annotation.Keep
|
||||
|
||||
@Keep
|
||||
class CheatEngine(titleId: Long) {
|
||||
@Keep
|
||||
private val mPointer: Long
|
||||
|
||||
init {
|
||||
mPointer = initialize(titleId)
|
||||
}
|
||||
|
||||
protected external fun finalize()
|
||||
object CheatEngine {
|
||||
external fun loadCheatFile(titleId: Long)
|
||||
external fun saveCheatFile(titleId: Long)
|
||||
|
||||
external fun getCheats(): Array<Cheat>
|
||||
|
||||
external fun addCheat(cheat: Cheat?)
|
||||
external fun removeCheat(index: Int)
|
||||
external fun updateCheat(index: Int, newCheat: Cheat?)
|
||||
external fun saveCheatFile()
|
||||
|
||||
companion object {
|
||||
@JvmStatic
|
||||
private external fun initialize(titleId: Long): Long
|
||||
}
|
||||
}
|
||||
|
@ -47,18 +47,19 @@ class CheatsViewModel : ViewModel() {
|
||||
val detailsViewFocusChange get() = _detailsViewFocusChange.asStateFlow()
|
||||
private val _detailsViewFocusChange = MutableStateFlow(false)
|
||||
|
||||
private var cheatEngine: CheatEngine? = null
|
||||
private var titleId: Long = 0
|
||||
lateinit var cheats: Array<Cheat>
|
||||
private var cheatsNeedSaving = false
|
||||
private var selectedCheatPosition = -1
|
||||
|
||||
fun initialize(titleId: Long) {
|
||||
cheatEngine = CheatEngine(titleId)
|
||||
fun initialize(titleId_: Long) {
|
||||
titleId = titleId_;
|
||||
load()
|
||||
}
|
||||
|
||||
private fun load() {
|
||||
cheats = cheatEngine!!.getCheats()
|
||||
CheatEngine.loadCheatFile(titleId)
|
||||
cheats = CheatEngine.getCheats()
|
||||
for (i in cheats.indices) {
|
||||
cheats[i].setEnabledChangedCallback {
|
||||
cheatsNeedSaving = true
|
||||
@ -69,7 +70,7 @@ class CheatsViewModel : ViewModel() {
|
||||
|
||||
fun saveIfNeeded() {
|
||||
if (cheatsNeedSaving) {
|
||||
cheatEngine!!.saveCheatFile()
|
||||
CheatEngine.saveCheatFile(titleId)
|
||||
cheatsNeedSaving = false
|
||||
}
|
||||
}
|
||||
@ -107,7 +108,7 @@ class CheatsViewModel : ViewModel() {
|
||||
_isAdding.value = false
|
||||
_isEditing.value = false
|
||||
val position = cheats.size
|
||||
cheatEngine!!.addCheat(cheat)
|
||||
CheatEngine.addCheat(cheat)
|
||||
cheatsNeedSaving = true
|
||||
load()
|
||||
notifyCheatAdded(position)
|
||||
@ -123,7 +124,7 @@ class CheatsViewModel : ViewModel() {
|
||||
}
|
||||
|
||||
fun updateSelectedCheat(newCheat: Cheat?) {
|
||||
cheatEngine!!.updateCheat(selectedCheatPosition, newCheat)
|
||||
CheatEngine.updateCheat(selectedCheatPosition, newCheat)
|
||||
cheatsNeedSaving = true
|
||||
load()
|
||||
notifyCheatUpdated(selectedCheatPosition)
|
||||
@ -141,7 +142,7 @@ class CheatsViewModel : ViewModel() {
|
||||
fun deleteSelectedCheat() {
|
||||
val position = selectedCheatPosition
|
||||
setSelectedCheat(null, -1)
|
||||
cheatEngine!!.removeCheat(position)
|
||||
CheatEngine.removeCheat(position)
|
||||
cheatsNeedSaving = true
|
||||
load()
|
||||
notifyCheatDeleted(position)
|
||||
|
@ -15,24 +15,24 @@
|
||||
|
||||
extern "C" {
|
||||
|
||||
static Cheats::CheatEngine* GetPointer(JNIEnv* env, jobject obj) {
|
||||
return reinterpret_cast<Cheats::CheatEngine*>(
|
||||
env->GetLongField(obj, IDCache::GetCheatEnginePointer()));
|
||||
static Cheats::CheatEngine& GetEngine() {
|
||||
Core::System& system{Core::System::GetInstance()};
|
||||
return system.CheatEngine();
|
||||
}
|
||||
|
||||
JNIEXPORT jlong JNICALL Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_initialize(
|
||||
JNIEXPORT void JNICALL Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_loadCheatFile(
|
||||
JNIEnv* env, jclass, jlong title_id) {
|
||||
return reinterpret_cast<jlong>(new Cheats::CheatEngine(title_id, Core::System::GetInstance()));
|
||||
GetEngine().LoadCheatFile(title_id);
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_finalize(JNIEnv* env, jobject obj) {
|
||||
delete GetPointer(env, obj);
|
||||
JNIEXPORT void JNICALL Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_saveCheatFile(
|
||||
JNIEnv* env, jclass, jlong title_id) {
|
||||
GetEngine().SaveCheatFile(title_id);
|
||||
}
|
||||
|
||||
JNIEXPORT jobjectArray JNICALL
|
||||
Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_getCheats(JNIEnv* env, jobject obj) {
|
||||
auto cheats = GetPointer(env, obj)->GetCheats();
|
||||
Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_getCheats(JNIEnv* env, jclass) {
|
||||
auto cheats = GetEngine().GetCheats();
|
||||
|
||||
const jobjectArray array =
|
||||
env->NewObjectArray(static_cast<jsize>(cheats.size()), IDCache::GetCheatClass(), nullptr);
|
||||
@ -45,22 +45,19 @@ Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_getCheats(JNIEnv* en
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_addCheat(
|
||||
JNIEnv* env, jobject obj, jobject j_cheat) {
|
||||
GetPointer(env, obj)->AddCheat(*CheatFromJava(env, j_cheat));
|
||||
JNIEnv* env, jclass, jobject j_cheat) {
|
||||
auto cheat = *CheatFromJava(env, j_cheat);
|
||||
GetEngine().AddCheat(std::move(cheat));
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_removeCheat(
|
||||
JNIEnv* env, jobject obj, jint index) {
|
||||
GetPointer(env, obj)->RemoveCheat(index);
|
||||
JNIEnv* env, jclass, jint index) {
|
||||
GetEngine().RemoveCheat(index);
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_updateCheat(
|
||||
JNIEnv* env, jobject obj, jint index, jobject j_new_cheat) {
|
||||
GetPointer(env, obj)->UpdateCheat(index, *CheatFromJava(env, j_new_cheat));
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_org_citra_citra_1emu_features_cheats_model_CheatEngine_saveCheatFile(
|
||||
JNIEnv* env, jobject obj) {
|
||||
GetPointer(env, obj)->SaveCheatFile();
|
||||
JNIEnv* env, jclass, jint index, jobject j_new_cheat) {
|
||||
auto cheat = *CheatFromJava(env, j_new_cheat);
|
||||
GetEngine().UpdateCheat(index, std::move(cheat));
|
||||
}
|
||||
}
|
||||
|
@ -146,6 +146,7 @@ void Config::ReadValues() {
|
||||
ReadSetting("Renderer", Settings::values.use_disk_shader_cache);
|
||||
ReadSetting("Renderer", Settings::values.use_vsync_new);
|
||||
ReadSetting("Renderer", Settings::values.texture_filter);
|
||||
ReadSetting("Renderer", Settings::values.texture_sampling);
|
||||
|
||||
// Work around to map Android setting for enabling the frame limiter to the format Citra expects
|
||||
if (sdl2_config->GetBoolean("Renderer", "use_frame_limit", true)) {
|
||||
|
@ -15,7 +15,6 @@
|
||||
#include "jni/input_manager.h"
|
||||
#include "network/network.h"
|
||||
#include "video_core/renderer_base.h"
|
||||
#include "video_core/video_core.h"
|
||||
|
||||
static bool IsPortraitMode() {
|
||||
return JNI_FALSE != IDCache::GetEnvForThread()->CallStaticBooleanMethod(
|
||||
|
@ -7,6 +7,10 @@
|
||||
#include <vector>
|
||||
#include "core/frontend/emu_window.h"
|
||||
|
||||
namespace Core {
|
||||
class System;
|
||||
}
|
||||
|
||||
class EmuWindow_Android : public Frontend::EmuWindow {
|
||||
public:
|
||||
EmuWindow_Android(ANativeWindow* surface);
|
||||
|
@ -12,10 +12,11 @@
|
||||
|
||||
#include "common/logging/log.h"
|
||||
#include "common/settings.h"
|
||||
#include "core/core.h"
|
||||
#include "input_common/main.h"
|
||||
#include "jni/emu_window/emu_window_gl.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/renderer_base.h"
|
||||
#include "video_core/video_core.h"
|
||||
|
||||
static constexpr std::array<EGLint, 15> egl_attribs{EGL_SURFACE_TYPE,
|
||||
EGL_WINDOW_BIT,
|
||||
@ -71,8 +72,8 @@ private:
|
||||
EGLContext egl_context{};
|
||||
};
|
||||
|
||||
EmuWindow_Android_OpenGL::EmuWindow_Android_OpenGL(ANativeWindow* surface)
|
||||
: EmuWindow_Android{surface} {
|
||||
EmuWindow_Android_OpenGL::EmuWindow_Android_OpenGL(Core::System& system_, ANativeWindow* surface)
|
||||
: EmuWindow_Android{surface}, system{system_} {
|
||||
if (egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY); egl_display == EGL_NO_DISPLAY) {
|
||||
LOG_CRITICAL(Frontend, "eglGetDisplay() failed");
|
||||
return;
|
||||
@ -199,6 +200,9 @@ void EmuWindow_Android_OpenGL::StopPresenting() {
|
||||
}
|
||||
|
||||
void EmuWindow_Android_OpenGL::TryPresenting() {
|
||||
if (!system.IsPoweredOn()) {
|
||||
return;
|
||||
}
|
||||
if (presenting_state == PresentingState::Initial) [[unlikely]] {
|
||||
eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context);
|
||||
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
||||
@ -208,8 +212,6 @@ void EmuWindow_Android_OpenGL::TryPresenting() {
|
||||
return;
|
||||
}
|
||||
eglSwapInterval(egl_display, Settings::values.use_vsync_new ? 1 : 0);
|
||||
if (VideoCore::g_renderer) {
|
||||
VideoCore::g_renderer->TryPresent(0);
|
||||
eglSwapBuffers(egl_display, egl_surface);
|
||||
}
|
||||
system.GPU().Renderer().TryPresent(0);
|
||||
eglSwapBuffers(egl_display, egl_surface);
|
||||
}
|
||||
|
@ -11,11 +11,15 @@
|
||||
|
||||
#include "jni/emu_window/emu_window.h"
|
||||
|
||||
namespace Core {
|
||||
class System;
|
||||
}
|
||||
|
||||
struct ANativeWindow;
|
||||
|
||||
class EmuWindow_Android_OpenGL : public EmuWindow_Android {
|
||||
public:
|
||||
EmuWindow_Android_OpenGL(ANativeWindow* surface);
|
||||
EmuWindow_Android_OpenGL(Core::System& system, ANativeWindow* surface);
|
||||
~EmuWindow_Android_OpenGL() override = default;
|
||||
|
||||
void TryPresenting() override;
|
||||
@ -30,6 +34,7 @@ private:
|
||||
void DestroyContext() override;
|
||||
|
||||
private:
|
||||
Core::System& system;
|
||||
EGLConfig egl_config;
|
||||
EGLSurface egl_surface{};
|
||||
EGLContext egl_context{};
|
||||
|
@ -7,7 +7,6 @@
|
||||
#include "common/logging/log.h"
|
||||
#include "common/settings.h"
|
||||
#include "jni/emu_window/emu_window_vk.h"
|
||||
#include "video_core/video_core.h"
|
||||
|
||||
class GraphicsContext_Android final : public Frontend::GraphicsContext {
|
||||
public:
|
||||
|
@ -35,8 +35,6 @@ static jclass s_cheat_class;
|
||||
static jfieldID s_cheat_pointer;
|
||||
static jmethodID s_cheat_constructor;
|
||||
|
||||
static jfieldID s_cheat_engine_pointer;
|
||||
|
||||
static jfieldID s_game_info_pointer;
|
||||
|
||||
static jclass s_disk_cache_progress_class;
|
||||
@ -116,10 +114,6 @@ jmethodID GetCheatConstructor() {
|
||||
return s_cheat_constructor;
|
||||
}
|
||||
|
||||
jfieldID GetCheatEnginePointer() {
|
||||
return s_cheat_engine_pointer;
|
||||
}
|
||||
|
||||
jfieldID GetGameInfoPointer() {
|
||||
return s_game_info_pointer;
|
||||
}
|
||||
@ -195,12 +189,6 @@ jint JNI_OnLoad(JavaVM* vm, void* reserved) {
|
||||
s_cheat_constructor = env->GetMethodID(cheat_class, "<init>", "(J)V");
|
||||
env->DeleteLocalRef(cheat_class);
|
||||
|
||||
// Initialize CheatEngine
|
||||
const jclass cheat_engine_class =
|
||||
env->FindClass("org/citra/citra_emu/features/cheats/model/CheatEngine");
|
||||
s_cheat_engine_pointer = env->GetFieldID(cheat_engine_class, "mPointer", "J");
|
||||
env->DeleteLocalRef(cheat_engine_class);
|
||||
|
||||
// Initialize GameInfo
|
||||
const jclass game_info_class = env->FindClass("org/citra/citra_emu/model/GameInfo");
|
||||
s_game_info_pointer = env->GetFieldID(game_info_class, "pointer", "J");
|
||||
|
@ -35,8 +35,6 @@ jclass GetCheatClass();
|
||||
jfieldID GetCheatPointer();
|
||||
jmethodID GetCheatConstructor();
|
||||
|
||||
jfieldID GetCheatEnginePointer();
|
||||
|
||||
jfieldID GetGameInfoPointer();
|
||||
|
||||
jclass GetDiskCacheProgressClass();
|
||||
|
@ -51,8 +51,9 @@
|
||||
#include "jni/id_cache.h"
|
||||
#include "jni/input_manager.h"
|
||||
#include "jni/ndk_motion.h"
|
||||
#include "video_core/debug_utils/debug_utils.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/renderer_base.h"
|
||||
#include "video_core/video_core.h"
|
||||
|
||||
#if CITRA_ARCH(arm64)
|
||||
#include <adrenotools/driver.h>
|
||||
@ -126,7 +127,7 @@ static bool CheckMicPermission() {
|
||||
|
||||
static Core::System::ResultStatus RunCitra(const std::string& filepath) {
|
||||
// Citra core only supports a single running instance
|
||||
std::lock_guard<std::mutex> lock(running_mutex);
|
||||
std::scoped_lock lock(running_mutex);
|
||||
|
||||
LOG_INFO(Frontend, "Citra starting...");
|
||||
|
||||
@ -137,10 +138,12 @@ static Core::System::ResultStatus RunCitra(const std::string& filepath) {
|
||||
return Core::System::ResultStatus::ErrorLoader;
|
||||
}
|
||||
|
||||
Core::System& system{Core::System::GetInstance()};
|
||||
|
||||
const auto graphics_api = Settings::values.graphics_api.GetValue();
|
||||
switch (graphics_api) {
|
||||
case Settings::GraphicsAPI::OpenGL:
|
||||
window = std::make_unique<EmuWindow_Android_OpenGL>(s_surf);
|
||||
window = std::make_unique<EmuWindow_Android_OpenGL>(system, s_surf);
|
||||
break;
|
||||
case Settings::GraphicsAPI::Vulkan:
|
||||
window = std::make_unique<EmuWindow_Android_Vulkan>(s_surf, vulkan_library);
|
||||
@ -150,8 +153,6 @@ static Core::System::ResultStatus RunCitra(const std::string& filepath) {
|
||||
window = std::make_unique<EmuWindow_Android_Vulkan>(s_surf, vulkan_library);
|
||||
}
|
||||
|
||||
Core::System& system{Core::System::GetInstance()};
|
||||
|
||||
// Forces a config reload on game boot, if the user changed settings in the UI
|
||||
Config{};
|
||||
// Replace with game-specific settings
|
||||
@ -179,6 +180,7 @@ static Core::System::ResultStatus RunCitra(const std::string& filepath) {
|
||||
// Register microphone permission check
|
||||
system.RegisterMicPermissionCheck(&CheckMicPermission);
|
||||
|
||||
Pica::g_debug_context = Pica::DebugContext::Construct();
|
||||
InputManager::Init();
|
||||
|
||||
window->MakeCurrent();
|
||||
@ -196,7 +198,7 @@ static Core::System::ResultStatus RunCitra(const std::string& filepath) {
|
||||
LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
|
||||
|
||||
std::unique_ptr<Frontend::GraphicsContext> cpu_context;
|
||||
system.Renderer().Rasterizer()->LoadDiskResources(stop_run, &LoadDiskCacheProgress);
|
||||
system.GPU().Renderer().Rasterizer()->LoadDiskResources(stop_run, &LoadDiskCacheProgress);
|
||||
|
||||
LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Complete, 0, 0);
|
||||
|
||||
@ -275,8 +277,10 @@ void Java_org_citra_citra_1emu_NativeLibrary_surfaceChanged(JNIEnv* env,
|
||||
if (window) {
|
||||
window->OnSurfaceChanged(s_surf);
|
||||
}
|
||||
if (VideoCore::g_renderer) {
|
||||
VideoCore::g_renderer->NotifySurfaceChanged();
|
||||
|
||||
auto& system = Core::System::GetInstance();
|
||||
if (system.IsPoweredOn()) {
|
||||
system.GPU().Renderer().NotifySurfaceChanged();
|
||||
}
|
||||
|
||||
LOG_INFO(Frontend, "Surface changed");
|
||||
@ -311,8 +315,9 @@ void Java_org_citra_citra_1emu_NativeLibrary_notifyOrientationChange([[maybe_unu
|
||||
jint layout_option,
|
||||
jint rotation) {
|
||||
Settings::values.layout_option = static_cast<Settings::LayoutOption>(layout_option);
|
||||
if (VideoCore::g_renderer) {
|
||||
VideoCore::g_renderer->UpdateCurrentFramebufferLayout(!(rotation % 2));
|
||||
auto& system = Core::System::GetInstance();
|
||||
if (system.IsPoweredOn()) {
|
||||
system.GPU().Renderer().UpdateCurrentFramebufferLayout(!(rotation % 2));
|
||||
}
|
||||
InputManager::screen_rotation = rotation;
|
||||
Camera::NDK::g_rotation = rotation;
|
||||
@ -322,8 +327,9 @@ void Java_org_citra_citra_1emu_NativeLibrary_swapScreens([[maybe_unused]] JNIEnv
|
||||
[[maybe_unused]] jobject obj,
|
||||
jboolean swap_screens, jint rotation) {
|
||||
Settings::values.swap_screen = swap_screens;
|
||||
if (VideoCore::g_renderer) {
|
||||
VideoCore::g_renderer->UpdateCurrentFramebufferLayout(!(rotation % 2));
|
||||
auto& system = Core::System::GetInstance();
|
||||
if (system.IsPoweredOn()) {
|
||||
system.GPU().Renderer().UpdateCurrentFramebufferLayout(!(rotation % 2));
|
||||
}
|
||||
InputManager::screen_rotation = rotation;
|
||||
Camera::NDK::g_rotation = rotation;
|
||||
|
@ -4,11 +4,11 @@ add_library(audio_core STATIC
|
||||
codec.h
|
||||
dsp_interface.cpp
|
||||
dsp_interface.h
|
||||
hle/aac_decoder.cpp
|
||||
hle/aac_decoder.h
|
||||
hle/common.h
|
||||
hle/decoder.cpp
|
||||
hle/decoder.h
|
||||
hle/faad2_decoder.cpp
|
||||
hle/faad2_decoder.h
|
||||
hle/filter.cpp
|
||||
hle/filter.h
|
||||
hle/hle.cpp
|
||||
|
@ -3,30 +3,11 @@
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include <neaacdec.h>
|
||||
#include "audio_core/hle/faad2_decoder.h"
|
||||
#include "audio_core/hle/aac_decoder.h"
|
||||
|
||||
namespace AudioCore::HLE {
|
||||
|
||||
class FAAD2Decoder::Impl {
|
||||
public:
|
||||
explicit Impl(Memory::MemorySystem& memory);
|
||||
~Impl();
|
||||
std::optional<BinaryMessage> ProcessRequest(const BinaryMessage& request);
|
||||
bool IsValid() const {
|
||||
return decoder != nullptr;
|
||||
}
|
||||
|
||||
private:
|
||||
std::optional<BinaryMessage> Initalize(const BinaryMessage& request);
|
||||
|
||||
std::optional<BinaryMessage> Decode(const BinaryMessage& request);
|
||||
|
||||
Memory::MemorySystem& memory;
|
||||
|
||||
NeAACDecHandle decoder = nullptr;
|
||||
};
|
||||
|
||||
FAAD2Decoder::Impl::Impl(Memory::MemorySystem& memory) : memory(memory) {
|
||||
AACDecoder::AACDecoder(Memory::MemorySystem& memory) : memory(memory) {
|
||||
decoder = NeAACDecOpen();
|
||||
if (decoder == nullptr) {
|
||||
LOG_CRITICAL(Audio_DSP, "Could not open FAAD2 decoder.");
|
||||
@ -46,7 +27,7 @@ FAAD2Decoder::Impl::Impl(Memory::MemorySystem& memory) : memory(memory) {
|
||||
LOG_INFO(Audio_DSP, "Created FAAD2 AAC decoder.");
|
||||
}
|
||||
|
||||
FAAD2Decoder::Impl::~Impl() {
|
||||
AACDecoder::~AACDecoder() {
|
||||
if (decoder) {
|
||||
NeAACDecClose(decoder);
|
||||
decoder = nullptr;
|
||||
@ -55,16 +36,23 @@ FAAD2Decoder::Impl::~Impl() {
|
||||
}
|
||||
}
|
||||
|
||||
std::optional<BinaryMessage> FAAD2Decoder::Impl::ProcessRequest(const BinaryMessage& request) {
|
||||
BinaryMessage AACDecoder::ProcessRequest(const BinaryMessage& request) {
|
||||
if (request.header.codec != DecoderCodec::DecodeAAC) {
|
||||
LOG_ERROR(Audio_DSP, "FAAD2 AAC Decoder cannot handle such codec: {}",
|
||||
LOG_ERROR(Audio_DSP, "AAC decoder received unsupported codec: {}",
|
||||
static_cast<u16>(request.header.codec));
|
||||
return {};
|
||||
return {
|
||||
.header =
|
||||
{
|
||||
.result = ResultStatus::Error,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
switch (request.header.cmd) {
|
||||
case DecoderCommand::Init: {
|
||||
return Initalize(request);
|
||||
BinaryMessage response = request;
|
||||
response.header.result = ResultStatus::Success;
|
||||
return response;
|
||||
}
|
||||
case DecoderCommand::EncodeDecode: {
|
||||
return Decode(request);
|
||||
@ -72,26 +60,25 @@ std::optional<BinaryMessage> FAAD2Decoder::Impl::ProcessRequest(const BinaryMess
|
||||
case DecoderCommand::Shutdown:
|
||||
case DecoderCommand::SaveState:
|
||||
case DecoderCommand::LoadState: {
|
||||
LOG_WARNING(Audio_DSP, "Got unimplemented binary request: {}",
|
||||
LOG_WARNING(Audio_DSP, "Got unimplemented AAC binary request: {}",
|
||||
static_cast<u16>(request.header.cmd));
|
||||
BinaryMessage response = request;
|
||||
response.header.result = ResultStatus::Success;
|
||||
return response;
|
||||
}
|
||||
default:
|
||||
LOG_ERROR(Audio_DSP, "Got unknown binary request: {}",
|
||||
LOG_ERROR(Audio_DSP, "Got unknown AAC binary request: {}",
|
||||
static_cast<u16>(request.header.cmd));
|
||||
return {};
|
||||
return {
|
||||
.header =
|
||||
{
|
||||
.result = ResultStatus::Error,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
std::optional<BinaryMessage> FAAD2Decoder::Impl::Initalize(const BinaryMessage& request) {
|
||||
BinaryMessage response = request;
|
||||
response.header.result = ResultStatus::Success;
|
||||
return response;
|
||||
}
|
||||
|
||||
std::optional<BinaryMessage> FAAD2Decoder::Impl::Decode(const BinaryMessage& request) {
|
||||
BinaryMessage AACDecoder::Decode(const BinaryMessage& request) {
|
||||
BinaryMessage response{};
|
||||
response.header.codec = request.header.codec;
|
||||
response.header.cmd = request.header.cmd;
|
||||
@ -101,6 +88,10 @@ std::optional<BinaryMessage> FAAD2Decoder::Impl::Decode(const BinaryMessage& req
|
||||
response.decode_aac_response.num_channels = 2;
|
||||
response.decode_aac_response.num_samples = 1024;
|
||||
|
||||
if (decoder == nullptr) {
|
||||
return response;
|
||||
}
|
||||
|
||||
if (request.decode_aac_request.src_addr < Memory::FCRAM_PADDR ||
|
||||
request.decode_aac_request.src_addr + request.decode_aac_request.size >
|
||||
Memory::FCRAM_PADDR + Memory::FCRAM_SIZE) {
|
||||
@ -171,16 +162,4 @@ std::optional<BinaryMessage> FAAD2Decoder::Impl::Decode(const BinaryMessage& req
|
||||
return response;
|
||||
}
|
||||
|
||||
FAAD2Decoder::FAAD2Decoder(Memory::MemorySystem& memory) : impl(std::make_unique<Impl>(memory)) {}
|
||||
|
||||
FAAD2Decoder::~FAAD2Decoder() = default;
|
||||
|
||||
std::optional<BinaryMessage> FAAD2Decoder::ProcessRequest(const BinaryMessage& request) {
|
||||
return impl->ProcessRequest(request);
|
||||
}
|
||||
|
||||
bool FAAD2Decoder::IsValid() const {
|
||||
return impl->IsValid();
|
||||
}
|
||||
|
||||
} // namespace AudioCore::HLE
|
26
src/audio_core/hle/aac_decoder.h
Normal file
26
src/audio_core/hle/aac_decoder.h
Normal file
@ -0,0 +1,26 @@
|
||||
// Copyright 2023 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "audio_core/hle/decoder.h"
|
||||
|
||||
namespace AudioCore::HLE {
|
||||
|
||||
using NeAACDecHandle = void*;
|
||||
|
||||
class AACDecoder final : public DecoderBase {
|
||||
public:
|
||||
explicit AACDecoder(Memory::MemorySystem& memory);
|
||||
~AACDecoder() override;
|
||||
BinaryMessage ProcessRequest(const BinaryMessage& request) override;
|
||||
|
||||
private:
|
||||
BinaryMessage Decode(const BinaryMessage& request);
|
||||
|
||||
Memory::MemorySystem& memory;
|
||||
NeAACDecHandle decoder = nullptr;
|
||||
};
|
||||
|
||||
} // namespace AudioCore::HLE
|
@ -32,34 +32,4 @@ DecoderSampleRate GetSampleRateEnum(u32 sample_rate) {
|
||||
}
|
||||
}
|
||||
|
||||
DecoderBase::~DecoderBase(){};
|
||||
|
||||
NullDecoder::NullDecoder() = default;
|
||||
|
||||
NullDecoder::~NullDecoder() = default;
|
||||
|
||||
std::optional<BinaryMessage> NullDecoder::ProcessRequest(const BinaryMessage& request) {
|
||||
BinaryMessage response{};
|
||||
switch (request.header.cmd) {
|
||||
case DecoderCommand::Init:
|
||||
case DecoderCommand::Shutdown:
|
||||
case DecoderCommand::SaveState:
|
||||
case DecoderCommand::LoadState:
|
||||
response = request;
|
||||
response.header.result = ResultStatus::Success;
|
||||
return response;
|
||||
case DecoderCommand::EncodeDecode:
|
||||
response.header.codec = request.header.codec;
|
||||
response.header.cmd = request.header.cmd;
|
||||
response.header.result = ResultStatus::Success;
|
||||
response.decode_aac_response.num_channels = 2; // Just assume stereo here
|
||||
response.decode_aac_response.size = request.decode_aac_request.size;
|
||||
response.decode_aac_response.num_samples = 1024; // Just assume 1024 here
|
||||
return response;
|
||||
default:
|
||||
LOG_ERROR(Audio_DSP, "Got unknown binary request: {}",
|
||||
static_cast<u16>(request.header.cmd));
|
||||
return std::nullopt;
|
||||
}
|
||||
};
|
||||
} // namespace AudioCore::HLE
|
||||
|
@ -135,21 +135,8 @@ enum_le<DecoderSampleRate> GetSampleRateEnum(u32 sample_rate);
|
||||
|
||||
class DecoderBase {
|
||||
public:
|
||||
virtual ~DecoderBase();
|
||||
virtual std::optional<BinaryMessage> ProcessRequest(const BinaryMessage& request) = 0;
|
||||
/// Return true if this Decoder can be loaded. Return false if the system cannot create the
|
||||
/// decoder
|
||||
virtual bool IsValid() const = 0;
|
||||
};
|
||||
|
||||
class NullDecoder final : public DecoderBase {
|
||||
public:
|
||||
NullDecoder();
|
||||
~NullDecoder() override;
|
||||
std::optional<BinaryMessage> ProcessRequest(const BinaryMessage& request) override;
|
||||
bool IsValid() const override {
|
||||
return true;
|
||||
}
|
||||
virtual ~DecoderBase() = default;
|
||||
virtual BinaryMessage ProcessRequest(const BinaryMessage& request) = 0;
|
||||
};
|
||||
|
||||
} // namespace AudioCore::HLE
|
||||
|
@ -1,23 +0,0 @@
|
||||
// Copyright 2023 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "audio_core/hle/decoder.h"
|
||||
|
||||
namespace AudioCore::HLE {
|
||||
|
||||
class FAAD2Decoder final : public DecoderBase {
|
||||
public:
|
||||
explicit FAAD2Decoder(Memory::MemorySystem& memory);
|
||||
~FAAD2Decoder() override;
|
||||
std::optional<BinaryMessage> ProcessRequest(const BinaryMessage& request) override;
|
||||
bool IsValid() const override;
|
||||
|
||||
private:
|
||||
class Impl;
|
||||
std::unique_ptr<Impl> impl;
|
||||
};
|
||||
|
||||
} // namespace AudioCore::HLE
|
@ -8,9 +8,9 @@
|
||||
#include <boost/serialization/vector.hpp>
|
||||
#include <boost/serialization/weak_ptr.hpp>
|
||||
#include "audio_core/audio_types.h"
|
||||
#include "audio_core/hle/aac_decoder.h"
|
||||
#include "audio_core/hle/common.h"
|
||||
#include "audio_core/hle/decoder.h"
|
||||
#include "audio_core/hle/faad2_decoder.h"
|
||||
#include "audio_core/hle/hle.h"
|
||||
#include "audio_core/hle/mixers.h"
|
||||
#include "audio_core/hle/shared_memory.h"
|
||||
@ -24,16 +24,10 @@
|
||||
#include "core/core.h"
|
||||
#include "core/core_timing.h"
|
||||
|
||||
SERIALIZE_EXPORT_IMPL(AudioCore::DspHle)
|
||||
|
||||
using InterruptType = Service::DSP::InterruptType;
|
||||
|
||||
namespace AudioCore {
|
||||
|
||||
DspHle::DspHle()
|
||||
: DspHle(Core::System::GetInstance(), Core::System::GetInstance().Memory(),
|
||||
Core::System::GetInstance().CoreTiming()) {}
|
||||
|
||||
DspHle::DspHle(Core::System& system) : DspHle(system, system.Memory(), system.CoreTiming()) {}
|
||||
|
||||
template <class Archive>
|
||||
@ -98,7 +92,7 @@ private:
|
||||
Core::Timing& core_timing;
|
||||
Core::TimingEventType* tick_event{};
|
||||
|
||||
std::unique_ptr<HLE::DecoderBase> decoder{};
|
||||
std::unique_ptr<HLE::DecoderBase> aac_decoder{};
|
||||
|
||||
std::function<void(Service::DSP::InterruptType type, DspPipe pipe)> interrupt_handler{};
|
||||
|
||||
@ -114,13 +108,6 @@ private:
|
||||
friend class boost::serialization::access;
|
||||
};
|
||||
|
||||
static std::vector<std::function<std::unique_ptr<HLE::DecoderBase>(Memory::MemorySystem&)>>
|
||||
decoder_backends = {
|
||||
[](Memory::MemorySystem& memory) -> std::unique_ptr<HLE::DecoderBase> {
|
||||
return std::make_unique<HLE::FAAD2Decoder>(memory);
|
||||
},
|
||||
};
|
||||
|
||||
DspHle::Impl::Impl(DspHle& parent_, Memory::MemorySystem& memory, Core::Timing& timing)
|
||||
: parent(parent_), core_timing(timing) {
|
||||
dsp_memory.raw_memory.fill(0);
|
||||
@ -129,19 +116,7 @@ DspHle::Impl::Impl(DspHle& parent_, Memory::MemorySystem& memory, Core::Timing&
|
||||
source.SetMemory(memory);
|
||||
}
|
||||
|
||||
for (auto& factory : decoder_backends) {
|
||||
decoder = factory(memory);
|
||||
if (decoder && decoder->IsValid()) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!decoder || !decoder->IsValid()) {
|
||||
LOG_WARNING(Audio_DSP,
|
||||
"Unable to load any decoders, this could cause missing audio in some games");
|
||||
decoder = std::make_unique<HLE::NullDecoder>();
|
||||
}
|
||||
|
||||
aac_decoder = std::make_unique<HLE::AACDecoder>(memory);
|
||||
tick_event =
|
||||
core_timing.RegisterEvent("AudioCore::DspHle::tick_event", [this](u64, s64 cycles_late) {
|
||||
this->AudioTickCallback(cycles_late);
|
||||
@ -291,12 +266,9 @@ void DspHle::Impl::PipeWrite(DspPipe pipe_number, std::span<const u8> buffer) {
|
||||
UNIMPLEMENTED();
|
||||
return;
|
||||
}
|
||||
std::optional<HLE::BinaryMessage> response = decoder->ProcessRequest(request);
|
||||
if (response) {
|
||||
const HLE::BinaryMessage& value = *response;
|
||||
pipe_data[static_cast<u32>(pipe_number)].resize(sizeof(value));
|
||||
std::memcpy(pipe_data[static_cast<u32>(pipe_number)].data(), &value, sizeof(value));
|
||||
}
|
||||
const HLE::BinaryMessage response = aac_decoder->ProcessRequest(request);
|
||||
pipe_data[static_cast<u32>(pipe_number)].resize(sizeof(response));
|
||||
std::memcpy(pipe_data[static_cast<u32>(pipe_number)].data(), &response, sizeof(response));
|
||||
|
||||
interrupt_handler(InterruptType::Pipe, DspPipe::Binary);
|
||||
break;
|
||||
|
@ -50,13 +50,9 @@ private:
|
||||
friend struct Impl;
|
||||
std::unique_ptr<Impl> impl;
|
||||
|
||||
DspHle();
|
||||
|
||||
template <class Archive>
|
||||
void serialize(Archive& ar, const unsigned int);
|
||||
friend class boost::serialization::access;
|
||||
};
|
||||
|
||||
} // namespace AudioCore
|
||||
|
||||
BOOST_CLASS_EXPORT_KEY(AudioCore::DspHle)
|
||||
|
@ -24,8 +24,8 @@ namespace {
|
||||
constexpr std::array input_details = {
|
||||
#ifdef HAVE_CUBEB
|
||||
InputDetails{InputType::Cubeb, "Real Device (Cubeb)", true,
|
||||
[](std::string_view device_id) -> std::unique_ptr<Input> {
|
||||
if (!Core::System::GetInstance().HasMicPermission()) {
|
||||
[](Core::System& system, std::string_view device_id) -> std::unique_ptr<Input> {
|
||||
if (!system.HasMicPermission()) {
|
||||
LOG_WARNING(Audio,
|
||||
"Microphone permission denied, falling back to null input.");
|
||||
return std::make_unique<NullInput>();
|
||||
@ -36,8 +36,8 @@ constexpr std::array input_details = {
|
||||
#endif
|
||||
#ifdef HAVE_OPENAL
|
||||
InputDetails{InputType::OpenAL, "Real Device (OpenAL)", true,
|
||||
[](std::string_view device_id) -> std::unique_ptr<Input> {
|
||||
if (!Core::System::GetInstance().HasMicPermission()) {
|
||||
[](Core::System& system, std::string_view device_id) -> std::unique_ptr<Input> {
|
||||
if (!system.HasMicPermission()) {
|
||||
LOG_WARNING(Audio,
|
||||
"Microphone permission denied, falling back to null input.");
|
||||
return std::make_unique<NullInput>();
|
||||
@ -47,12 +47,12 @@ constexpr std::array input_details = {
|
||||
&ListOpenALInputDevices},
|
||||
#endif
|
||||
InputDetails{InputType::Static, "Static Noise", false,
|
||||
[](std::string_view device_id) -> std::unique_ptr<Input> {
|
||||
[](Core::System& system, std::string_view device_id) -> std::unique_ptr<Input> {
|
||||
return std::make_unique<StaticInput>();
|
||||
},
|
||||
[] { return std::vector<std::string>{"Static Noise"}; }},
|
||||
InputDetails{InputType::Null, "None", false,
|
||||
[](std::string_view device_id) -> std::unique_ptr<Input> {
|
||||
[](Core::System& system, std::string_view device_id) -> std::unique_ptr<Input> {
|
||||
return std::make_unique<NullInput>();
|
||||
},
|
||||
[] { return std::vector<std::string>{"None"}; }},
|
||||
|
@ -10,6 +10,10 @@
|
||||
#include <vector>
|
||||
#include "common/common_types.h"
|
||||
|
||||
namespace Core {
|
||||
class System;
|
||||
}
|
||||
|
||||
namespace AudioCore {
|
||||
|
||||
class Input;
|
||||
@ -23,7 +27,7 @@ enum class InputType : u32 {
|
||||
};
|
||||
|
||||
struct InputDetails {
|
||||
using FactoryFn = std::unique_ptr<Input> (*)(std::string_view device_id);
|
||||
using FactoryFn = std::unique_ptr<Input> (*)(Core::System& system, std::string_view device_id);
|
||||
using ListDevicesFn = std::vector<std::string> (*)();
|
||||
|
||||
/// Type of this input.
|
||||
|
@ -36,6 +36,7 @@
|
||||
#include "core/telemetry_session.h"
|
||||
#include "input_common/main.h"
|
||||
#include "network/network.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/renderer_base.h"
|
||||
|
||||
#ifdef __unix__
|
||||
@ -438,9 +439,10 @@ int main(int argc, char** argv) {
|
||||
movie.StartRecording(movie_record, movie_record_author);
|
||||
}
|
||||
if (!dump_video.empty() && DynamicLibrary::FFmpeg::LoadFFmpeg()) {
|
||||
auto& renderer = system.GPU().Renderer();
|
||||
const auto layout{
|
||||
Layout::FrameLayoutFromResolutionScale(system.Renderer().GetResolutionScaleFactor())};
|
||||
auto dumper = std::make_shared<VideoDumper::FFmpegBackend>();
|
||||
Layout::FrameLayoutFromResolutionScale(renderer.GetResolutionScaleFactor())};
|
||||
auto dumper = std::make_shared<VideoDumper::FFmpegBackend>(renderer);
|
||||
if (dumper->StartDumping(dump_video, layout)) {
|
||||
system.RegisterVideoDumper(dumper);
|
||||
}
|
||||
@ -458,7 +460,7 @@ int main(int argc, char** argv) {
|
||||
});
|
||||
|
||||
std::atomic_bool stop_run;
|
||||
system.Renderer().Rasterizer()->LoadDiskResources(
|
||||
system.GPU().Renderer().Rasterizer()->LoadDiskResources(
|
||||
stop_run, [](VideoCore::LoadCallbackStage stage, std::size_t value, std::size_t total) {
|
||||
LOG_DEBUG(Frontend, "Loading stage {} progress {} {}", static_cast<u32>(stage), value,
|
||||
total);
|
||||
|
@ -146,6 +146,7 @@ void Config::ReadValues() {
|
||||
ReadSetting("Renderer", Settings::values.frame_limit);
|
||||
ReadSetting("Renderer", Settings::values.use_vsync_new);
|
||||
ReadSetting("Renderer", Settings::values.texture_filter);
|
||||
ReadSetting("Renderer", Settings::values.texture_sampling);
|
||||
|
||||
ReadSetting("Renderer", Settings::values.mono_render_option);
|
||||
ReadSetting("Renderer", Settings::values.render_3d);
|
||||
|
@ -11,8 +11,9 @@
|
||||
#include "citra/emu_window/emu_window_sdl2_gl.h"
|
||||
#include "common/scm_rev.h"
|
||||
#include "common/settings.h"
|
||||
#include "core/core.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/renderer_base.h"
|
||||
#include "video_core/video_core.h"
|
||||
|
||||
class SDLGLContext : public Frontend::GraphicsContext {
|
||||
public:
|
||||
@ -159,7 +160,7 @@ void EmuWindow_SDL2_GL::Present() {
|
||||
SDL_GL_MakeCurrent(render_window, window_context);
|
||||
SDL_GL_SetSwapInterval(1);
|
||||
while (IsOpen()) {
|
||||
VideoCore::g_renderer->TryPresent(100, is_secondary);
|
||||
system.GPU().Renderer().TryPresent(100, is_secondary);
|
||||
SDL_GL_SwapWindow(render_window);
|
||||
}
|
||||
SDL_GL_MakeCurrent(render_window, nullptr);
|
||||
|
@ -13,6 +13,7 @@
|
||||
#include "common/settings.h"
|
||||
#include "core/core.h"
|
||||
#include "core/frontend/emu_window.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/renderer_software/renderer_software.h"
|
||||
|
||||
class DummyContext : public Frontend::GraphicsContext {};
|
||||
@ -94,7 +95,7 @@ void EmuWindow_SDL2_SW::Present() {
|
||||
}
|
||||
|
||||
SDL_Surface* EmuWindow_SDL2_SW::LoadFramebuffer(VideoCore::ScreenId screen_id) {
|
||||
const auto& renderer = static_cast<SwRenderer::RendererSoftware&>(system.Renderer());
|
||||
const auto& renderer = static_cast<SwRenderer::RendererSoftware&>(system.GPU().Renderer());
|
||||
const auto& info = renderer.Screen(screen_id);
|
||||
const int width = static_cast<int>(info.width);
|
||||
const int height = static_cast<int>(info.height);
|
||||
|
@ -22,9 +22,9 @@
|
||||
#include "input_common/main.h"
|
||||
#include "input_common/motion_emu.h"
|
||||
#include "video_core/custom_textures/custom_tex_manager.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/renderer_base.h"
|
||||
#include "video_core/renderer_software/renderer_software.h"
|
||||
#include "video_core/video_core.h"
|
||||
|
||||
#ifdef HAS_OPENGL
|
||||
#include <glad/glad.h>
|
||||
@ -73,7 +73,7 @@ void EmuThread::run() {
|
||||
|
||||
emit LoadProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
|
||||
|
||||
system.Renderer().Rasterizer()->LoadDiskResources(
|
||||
system.GPU().Renderer().Rasterizer()->LoadDiskResources(
|
||||
stop_run, [this](VideoCore::LoadCallbackStage stage, std::size_t value, std::size_t total) {
|
||||
emit LoadProgress(stage, value, total);
|
||||
});
|
||||
@ -284,9 +284,7 @@ public:
|
||||
}
|
||||
context->MakeCurrent();
|
||||
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
||||
if (VideoCore::g_renderer) {
|
||||
VideoCore::g_renderer->TryPresent(100, is_secondary);
|
||||
}
|
||||
system.GPU().Renderer().TryPresent(100, is_secondary);
|
||||
context->SwapBuffers();
|
||||
glFinish();
|
||||
}
|
||||
@ -367,7 +365,7 @@ struct SoftwareRenderWidget : public RenderWidget {
|
||||
}
|
||||
|
||||
QImage LoadFramebuffer(VideoCore::ScreenId screen_id) {
|
||||
const auto& renderer = static_cast<SwRenderer::RendererSoftware&>(system.Renderer());
|
||||
const auto& renderer = static_cast<SwRenderer::RendererSoftware&>(system.GPU().Renderer());
|
||||
const auto& info = renderer.Screen(screen_id);
|
||||
const int width = static_cast<int>(info.width);
|
||||
const int height = static_cast<int>(info.height);
|
||||
@ -678,13 +676,14 @@ void GRenderWindow::ReleaseRenderTarget() {
|
||||
}
|
||||
|
||||
void GRenderWindow::CaptureScreenshot(u32 res_scale, const QString& screenshot_path) {
|
||||
auto& renderer = system.GPU().Renderer();
|
||||
if (res_scale == 0) {
|
||||
res_scale = system.Renderer().GetResolutionScaleFactor();
|
||||
res_scale = renderer.GetResolutionScaleFactor();
|
||||
}
|
||||
|
||||
const auto layout{Layout::FrameLayoutFromResolutionScale(res_scale, is_secondary)};
|
||||
screenshot_image = QImage(QSize(layout.width, layout.height), QImage::Format_RGB32);
|
||||
system.Renderer().RequestScreenshot(
|
||||
renderer.RequestScreenshot(
|
||||
screenshot_image.bits(),
|
||||
[this, screenshot_path](bool invert_y) {
|
||||
const std::string std_screenshot_path = screenshot_path.toStdString();
|
||||
|
@ -645,6 +645,7 @@ void Config::ReadRendererValues() {
|
||||
ReadGlobalSetting(Settings::values.bg_blue);
|
||||
|
||||
ReadGlobalSetting(Settings::values.texture_filter);
|
||||
ReadGlobalSetting(Settings::values.texture_sampling);
|
||||
|
||||
if (global) {
|
||||
ReadBasicSetting(Settings::values.use_shader_jit);
|
||||
@ -1130,6 +1131,7 @@ void Config::SaveRendererValues() {
|
||||
WriteGlobalSetting(Settings::values.bg_blue);
|
||||
|
||||
WriteGlobalSetting(Settings::values.texture_filter);
|
||||
WriteGlobalSetting(Settings::values.texture_sampling);
|
||||
|
||||
if (global) {
|
||||
WriteSetting(QStringLiteral("use_shader_jit"), Settings::values.use_shader_jit.GetValue(),
|
||||
|
@ -11,8 +11,10 @@
|
||||
#include "core/cheats/gateway_cheat.h"
|
||||
#include "ui_configure_cheats.h"
|
||||
|
||||
ConfigureCheats::ConfigureCheats(Core::System& system, u64 title_id_, QWidget* parent)
|
||||
: QWidget(parent), ui(std::make_unique<Ui::ConfigureCheats>()), title_id{title_id_} {
|
||||
ConfigureCheats::ConfigureCheats(Cheats::CheatEngine& cheat_engine_, u64 title_id_, QWidget* parent)
|
||||
: QWidget(parent),
|
||||
ui(std::make_unique<Ui::ConfigureCheats>()), cheat_engine{cheat_engine_}, title_id{
|
||||
title_id_} {
|
||||
// Setup gui control settings
|
||||
ui->setupUi(this);
|
||||
ui->tableCheats->setColumnWidth(0, 30);
|
||||
@ -34,15 +36,14 @@ ConfigureCheats::ConfigureCheats(Core::System& system, u64 title_id_, QWidget* p
|
||||
[this] { SaveCheat(ui->tableCheats->currentRow()); });
|
||||
connect(ui->buttonDelete, &QPushButton::clicked, this, &ConfigureCheats::OnDeleteCheat);
|
||||
|
||||
cheat_engine = std::make_unique<Cheats::CheatEngine>(title_id, system);
|
||||
|
||||
cheat_engine.LoadCheatFile(title_id);
|
||||
LoadCheats();
|
||||
}
|
||||
|
||||
ConfigureCheats::~ConfigureCheats() = default;
|
||||
|
||||
void ConfigureCheats::LoadCheats() {
|
||||
cheats = cheat_engine->GetCheats();
|
||||
cheats = cheat_engine.GetCheats();
|
||||
const int cheats_count = static_cast<int>(cheats.size());
|
||||
|
||||
ui->tableCheats->setRowCount(cheats_count);
|
||||
@ -106,12 +107,12 @@ bool ConfigureCheats::SaveCheat(int row) {
|
||||
ui->textNotes->toPlainText().toStdString());
|
||||
|
||||
if (newly_created) {
|
||||
cheat_engine->AddCheat(cheat);
|
||||
cheat_engine.AddCheat(std::move(cheat));
|
||||
newly_created = false;
|
||||
} else {
|
||||
cheat_engine->UpdateCheat(row, cheat);
|
||||
cheat_engine.UpdateCheat(row, std::move(cheat));
|
||||
}
|
||||
cheat_engine->SaveCheatFile();
|
||||
cheat_engine.SaveCheatFile(title_id);
|
||||
|
||||
int previous_row = ui->tableCheats->currentRow();
|
||||
int previous_col = ui->tableCheats->currentColumn();
|
||||
@ -161,7 +162,7 @@ void ConfigureCheats::OnCheckChanged(int state) {
|
||||
const QCheckBox* checkbox = qobject_cast<QCheckBox*>(sender());
|
||||
int row = static_cast<int>(checkbox->property("row").toInt());
|
||||
cheats[row]->SetEnabled(state);
|
||||
cheat_engine->SaveCheatFile();
|
||||
cheat_engine.SaveCheatFile(title_id);
|
||||
}
|
||||
|
||||
void ConfigureCheats::OnTextEdited() {
|
||||
@ -173,8 +174,8 @@ void ConfigureCheats::OnDeleteCheat() {
|
||||
if (newly_created) {
|
||||
newly_created = false;
|
||||
} else {
|
||||
cheat_engine->RemoveCheat(ui->tableCheats->currentRow());
|
||||
cheat_engine->SaveCheatFile();
|
||||
cheat_engine.RemoveCheat(ui->tableCheats->currentRow());
|
||||
cheat_engine.SaveCheatFile(title_id);
|
||||
}
|
||||
|
||||
LoadCheats();
|
||||
|
@ -5,6 +5,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <memory>
|
||||
#include <span>
|
||||
#include <QWidget>
|
||||
#include "common/common_types.h"
|
||||
|
||||
@ -25,7 +26,8 @@ class ConfigureCheats : public QWidget {
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
explicit ConfigureCheats(Core::System& system, u64 title_id, QWidget* parent = nullptr);
|
||||
explicit ConfigureCheats(Cheats::CheatEngine& cheat_engine, u64 title_id_,
|
||||
QWidget* parent = nullptr);
|
||||
~ConfigureCheats();
|
||||
bool ApplyConfiguration();
|
||||
|
||||
@ -58,9 +60,9 @@ private slots:
|
||||
|
||||
private:
|
||||
std::unique_ptr<Ui::ConfigureCheats> ui;
|
||||
std::vector<std::shared_ptr<Cheats::CheatBase>> cheats;
|
||||
Cheats::CheatEngine& cheat_engine;
|
||||
std::span<const std::shared_ptr<Cheats::CheatBase>> cheats;
|
||||
bool edited = false, newly_created = false;
|
||||
int last_row = -1, last_col = -1;
|
||||
u64 title_id;
|
||||
std::unique_ptr<Cheats::CheatEngine> cheat_engine;
|
||||
};
|
||||
|
@ -20,7 +20,6 @@ ConfigureGraphics::ConfigureGraphics(std::span<const QString> physical_devices,
|
||||
ui->physical_device_combo->addItem(name);
|
||||
}
|
||||
|
||||
ui->toggle_vsync_new->setEnabled(!is_powered_on);
|
||||
ui->graphics_api_combo->setEnabled(!is_powered_on);
|
||||
ui->physical_device_combo->setEnabled(!is_powered_on);
|
||||
ui->toggle_async_shaders->setEnabled(!is_powered_on);
|
||||
|
@ -38,7 +38,7 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const QString
|
||||
graphics_tab = std::make_unique<ConfigureGraphics>(physical_devices, is_powered_on, this);
|
||||
system_tab = std::make_unique<ConfigureSystem>(system, this);
|
||||
debug_tab = std::make_unique<ConfigureDebug>(is_powered_on, this);
|
||||
cheat_tab = std::make_unique<ConfigureCheats>(system, title_id, this);
|
||||
cheat_tab = std::make_unique<ConfigureCheats>(system.CheatEngine(), title_id, this);
|
||||
|
||||
ui->setupUi(this);
|
||||
|
||||
|
@ -5,8 +5,8 @@
|
||||
#include <QListView>
|
||||
#include "citra_qt/debugger/graphics/graphics.h"
|
||||
#include "citra_qt/util/util.h"
|
||||
|
||||
extern GraphicsDebugger g_debugger;
|
||||
#include "core/core.h"
|
||||
#include "video_core/gpu.h"
|
||||
|
||||
GPUCommandStreamItemModel::GPUCommandStreamItemModel(QObject* parent)
|
||||
: QAbstractListModel(parent), command_count(0) {
|
||||
@ -19,19 +19,19 @@ int GPUCommandStreamItemModel::rowCount([[maybe_unused]] const QModelIndex& pare
|
||||
}
|
||||
|
||||
QVariant GPUCommandStreamItemModel::data(const QModelIndex& index, int role) const {
|
||||
if (!index.isValid())
|
||||
if (!index.isValid() || !GetDebugger())
|
||||
return QVariant();
|
||||
|
||||
int command_index = index.row();
|
||||
const Service::GSP::Command& command = GetDebugger()->ReadGXCommandHistory(command_index);
|
||||
if (role == Qt::DisplayRole) {
|
||||
std::map<Service::GSP::CommandId, const char*> command_names = {
|
||||
{Service::GSP::CommandId::REQUEST_DMA, "REQUEST_DMA"},
|
||||
{Service::GSP::CommandId::SUBMIT_GPU_CMDLIST, "SUBMIT_GPU_CMDLIST"},
|
||||
{Service::GSP::CommandId::SET_MEMORY_FILL, "SET_MEMORY_FILL"},
|
||||
{Service::GSP::CommandId::SET_DISPLAY_TRANSFER, "SET_DISPLAY_TRANSFER"},
|
||||
{Service::GSP::CommandId::SET_TEXTURE_COPY, "SET_TEXTURE_COPY"},
|
||||
{Service::GSP::CommandId::CACHE_FLUSH, "CACHE_FLUSH"},
|
||||
{Service::GSP::CommandId::RequestDma, "REQUEST_DMA"},
|
||||
{Service::GSP::CommandId::SubmitCmdList, "SUBMIT_GPU_CMDLIST"},
|
||||
{Service::GSP::CommandId::MemoryFill, "SET_MEMORY_FILL"},
|
||||
{Service::GSP::CommandId::DisplayTransfer, "SET_DISPLAY_TRANSFER"},
|
||||
{Service::GSP::CommandId::TextureCopy, "SET_TEXTURE_COPY"},
|
||||
{Service::GSP::CommandId::CacheFlush, "CACHE_FLUSH"},
|
||||
};
|
||||
const u32* command_data = reinterpret_cast<const u32*>(&command);
|
||||
QString str = QStringLiteral("%1 %2 %3 %4 %5 %6 %7 %8 %9")
|
||||
@ -63,8 +63,8 @@ void GPUCommandStreamItemModel::OnGXCommandFinishedInternal(int total_command_co
|
||||
emit dataChanged(index(prev_command_count, 0), index(total_command_count - 1, 0));
|
||||
}
|
||||
|
||||
GPUCommandStreamWidget::GPUCommandStreamWidget(QWidget* parent)
|
||||
: QDockWidget(tr("Graphics Debugger"), parent), model(this) {
|
||||
GPUCommandStreamWidget::GPUCommandStreamWidget(Core::System& system_, QWidget* parent)
|
||||
: QDockWidget(tr("Graphics Debugger"), parent), system{system_}, model(this) {
|
||||
setObjectName(QStringLiteral("GraphicsDebugger"));
|
||||
|
||||
auto* command_list = new QListView;
|
||||
@ -74,12 +74,26 @@ GPUCommandStreamWidget::GPUCommandStreamWidget(QWidget* parent)
|
||||
setWidget(command_list);
|
||||
}
|
||||
|
||||
void GPUCommandStreamWidget::Register() {
|
||||
auto& debugger = system.GPU().Debugger();
|
||||
debugger.RegisterObserver(&model);
|
||||
}
|
||||
|
||||
void GPUCommandStreamWidget::Unregister() {
|
||||
auto& debugger = system.GPU().Debugger();
|
||||
debugger.UnregisterObserver(&model);
|
||||
}
|
||||
|
||||
void GPUCommandStreamWidget::showEvent(QShowEvent* event) {
|
||||
g_debugger.RegisterObserver(&model);
|
||||
if (system.IsPoweredOn()) {
|
||||
Register();
|
||||
}
|
||||
QDockWidget::showEvent(event);
|
||||
}
|
||||
|
||||
void GPUCommandStreamWidget::hideEvent(QHideEvent* event) {
|
||||
g_debugger.UnregisterObserver(&model);
|
||||
if (system.IsPoweredOn()) {
|
||||
Unregister();
|
||||
}
|
||||
QDockWidget::hideEvent(event);
|
||||
}
|
||||
|
@ -8,8 +8,12 @@
|
||||
#include <QDockWidget>
|
||||
#include "video_core/gpu_debugger.h"
|
||||
|
||||
namespace Core {
|
||||
class System;
|
||||
}
|
||||
|
||||
class GPUCommandStreamItemModel : public QAbstractListModel,
|
||||
public GraphicsDebugger::DebuggerObserver {
|
||||
public VideoCore::GraphicsDebugger::DebuggerObserver {
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
@ -35,12 +39,16 @@ class GPUCommandStreamWidget : public QDockWidget {
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
GPUCommandStreamWidget(QWidget* parent = nullptr);
|
||||
GPUCommandStreamWidget(Core::System& system, QWidget* parent = nullptr);
|
||||
|
||||
void Register();
|
||||
void Unregister();
|
||||
|
||||
protected:
|
||||
void showEvent(QShowEvent* event) override;
|
||||
void hideEvent(QHideEvent* event) override;
|
||||
|
||||
private:
|
||||
Core::System& system;
|
||||
GPUCommandStreamItemModel model;
|
||||
};
|
||||
|
@ -18,7 +18,8 @@ BreakPointObserverDock::BreakPointObserverDock(std::shared_ptr<Pica::DebugContex
|
||||
&BreakPointObserverDock::OnBreakPointHit, Qt::BlockingQueuedConnection);
|
||||
}
|
||||
|
||||
void BreakPointObserverDock::OnPicaBreakPointHit(Pica::DebugContext::Event event, void* data) {
|
||||
void BreakPointObserverDock::OnPicaBreakPointHit(Pica::DebugContext::Event event,
|
||||
const void* data) {
|
||||
emit BreakPointHit(event, data);
|
||||
}
|
||||
|
||||
|
@ -20,14 +20,14 @@ public:
|
||||
BreakPointObserverDock(std::shared_ptr<Pica::DebugContext> debug_context, const QString& title,
|
||||
QWidget* parent = nullptr);
|
||||
|
||||
void OnPicaBreakPointHit(Pica::DebugContext::Event event, void* data) override;
|
||||
void OnPicaBreakPointHit(Pica::DebugContext::Event event, const void* data) override;
|
||||
void OnPicaResume() override;
|
||||
|
||||
signals:
|
||||
void Resumed();
|
||||
void BreakPointHit(Pica::DebugContext::Event event, void* data);
|
||||
void BreakPointHit(Pica::DebugContext::Event event, const void* data);
|
||||
|
||||
private:
|
||||
virtual void OnBreakPointHit(Pica::DebugContext::Event event, void* data) = 0;
|
||||
virtual void OnBreakPointHit(Pica::DebugContext::Event event, const void* data) = 0;
|
||||
virtual void OnResumed() = 0;
|
||||
};
|
||||
|
@ -191,12 +191,12 @@ GraphicsBreakPointsWidget::GraphicsBreakPointsWidget(
|
||||
setWidget(main_widget);
|
||||
}
|
||||
|
||||
void GraphicsBreakPointsWidget::OnPicaBreakPointHit(Event event, void* data) {
|
||||
void GraphicsBreakPointsWidget::OnPicaBreakPointHit(Event event, const void* data) {
|
||||
// Process in GUI thread
|
||||
emit BreakPointHit(event, data);
|
||||
}
|
||||
|
||||
void GraphicsBreakPointsWidget::OnBreakPointHit(Pica::DebugContext::Event event, void* data) {
|
||||
void GraphicsBreakPointsWidget::OnBreakPointHit(Pica::DebugContext::Event event, const void* data) {
|
||||
status_text->setText(tr("Emulation halted at breakpoint"));
|
||||
resume_button->setEnabled(true);
|
||||
}
|
||||
|
@ -23,16 +23,16 @@ public:
|
||||
explicit GraphicsBreakPointsWidget(std::shared_ptr<Pica::DebugContext> debug_context,
|
||||
QWidget* parent = nullptr);
|
||||
|
||||
void OnPicaBreakPointHit(Pica::DebugContext::Event event, void* data) override;
|
||||
void OnPicaBreakPointHit(Pica::DebugContext::Event event, const void* data) override;
|
||||
void OnPicaResume() override;
|
||||
|
||||
signals:
|
||||
void Resumed();
|
||||
void BreakPointHit(Pica::DebugContext::Event event, void* data);
|
||||
void BreakPointHit(Pica::DebugContext::Event event, const void* data);
|
||||
void BreakPointsChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight);
|
||||
|
||||
private:
|
||||
void OnBreakPointHit(Pica::DebugContext::Event event, void* data);
|
||||
void OnBreakPointHit(Pica::DebugContext::Event event, const void* data);
|
||||
void OnItemDoubleClicked(const QModelIndex&);
|
||||
void OnResumeRequested();
|
||||
void OnResumed();
|
||||
|
@ -19,8 +19,8 @@
|
||||
#include "core/core.h"
|
||||
#include "core/memory.h"
|
||||
#include "video_core/debug_utils/debug_utils.h"
|
||||
#include "video_core/pica_state.h"
|
||||
#include "video_core/regs.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/pica/pica_core.h"
|
||||
#include "video_core/texture/texture_decode.h"
|
||||
|
||||
namespace {
|
||||
@ -73,7 +73,7 @@ QVariant GPUCommandListModel::data(const QModelIndex& index, int role) const {
|
||||
if (role == Qt::DisplayRole) {
|
||||
switch (index.column()) {
|
||||
case 0:
|
||||
return QString::fromLatin1(Pica::Regs::GetRegisterName(write.cmd_id));
|
||||
return QString::fromLatin1(Pica::RegsInternal::GetRegisterName(write.cmd_id));
|
||||
case 1:
|
||||
return QStringLiteral("%1").arg(write.cmd_id, 3, 16, QLatin1Char('0'));
|
||||
case 2:
|
||||
@ -119,8 +119,7 @@ void GPUCommandListModel::OnPicaTraceFinished(const Pica::DebugUtils::PicaTrace&
|
||||
}
|
||||
|
||||
#define COMMAND_IN_RANGE(cmd_id, reg_name) \
|
||||
(cmd_id >= PICA_REG_INDEX(reg_name) && \
|
||||
cmd_id < PICA_REG_INDEX(reg_name) + sizeof(decltype(Pica::g_state.regs.reg_name)) / 4)
|
||||
(cmd_id >= PICA_REG_INDEX(reg_name) && cmd_id <= PICA_REG_INDEX(reg_name))
|
||||
|
||||
void GPUCommandListWidget::OnCommandDoubleClicked(const QModelIndex& index) {
|
||||
const unsigned int command_id =
|
||||
@ -147,13 +146,13 @@ void GPUCommandListWidget::OnCommandDoubleClicked(const QModelIndex& index) {
|
||||
void GPUCommandListWidget::SetCommandInfo(const QModelIndex& index) {
|
||||
QWidget* new_info_widget = nullptr;
|
||||
|
||||
const unsigned int command_id =
|
||||
const u32 command_id =
|
||||
list_widget->model()->data(index, GPUCommandListModel::CommandIdRole).toUInt();
|
||||
if (COMMAND_IN_RANGE(command_id, texturing.texture0) ||
|
||||
COMMAND_IN_RANGE(command_id, texturing.texture1) ||
|
||||
COMMAND_IN_RANGE(command_id, texturing.texture2)) {
|
||||
|
||||
unsigned texture_index;
|
||||
u32 texture_index;
|
||||
if (COMMAND_IN_RANGE(command_id, texturing.texture0)) {
|
||||
texture_index = 0;
|
||||
} else if (COMMAND_IN_RANGE(command_id, texturing.texture1)) {
|
||||
@ -162,7 +161,8 @@ void GPUCommandListWidget::SetCommandInfo(const QModelIndex& index) {
|
||||
texture_index = 2;
|
||||
}
|
||||
|
||||
const auto texture = Pica::g_state.regs.texturing.GetTextures()[texture_index];
|
||||
auto& pica = system.GPU().PicaCore();
|
||||
const auto texture = pica.regs.internal.texturing.GetTextures()[texture_index];
|
||||
const auto config = texture.config;
|
||||
const auto format = texture.format;
|
||||
|
||||
|
@ -15,10 +15,10 @@
|
||||
#include "citra_qt/debugger/graphics/graphics_surface.h"
|
||||
#include "citra_qt/util/spinbox.h"
|
||||
#include "common/color.h"
|
||||
#include "core/core.h"
|
||||
#include "core/memory.h"
|
||||
#include "video_core/pica_state.h"
|
||||
#include "video_core/regs_framebuffer.h"
|
||||
#include "video_core/regs_texturing.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/pica/pica_core.h"
|
||||
#include "video_core/texture/texture_decode.h"
|
||||
#include "video_core/utils.h"
|
||||
|
||||
@ -49,10 +49,10 @@ void SurfacePicture::mouseMoveEvent(QMouseEvent* event) {
|
||||
mousePressEvent(event);
|
||||
}
|
||||
|
||||
GraphicsSurfaceWidget::GraphicsSurfaceWidget(Memory::MemorySystem& memory_,
|
||||
GraphicsSurfaceWidget::GraphicsSurfaceWidget(Core::System& system_,
|
||||
std::shared_ptr<Pica::DebugContext> debug_context,
|
||||
QWidget* parent)
|
||||
: BreakPointObserverDock(debug_context, tr("Pica Surface Viewer"), parent), memory{memory_},
|
||||
: BreakPointObserverDock(debug_context, tr("Pica Surface Viewer"), parent), system{system_},
|
||||
surface_source(Source::ColorBuffer) {
|
||||
setObjectName(QStringLiteral("PicaSurface"));
|
||||
|
||||
@ -214,7 +214,7 @@ GraphicsSurfaceWidget::GraphicsSurfaceWidget(Memory::MemorySystem& memory_,
|
||||
}
|
||||
}
|
||||
|
||||
void GraphicsSurfaceWidget::OnBreakPointHit(Pica::DebugContext::Event event, void* data) {
|
||||
void GraphicsSurfaceWidget::OnBreakPointHit(Pica::DebugContext::Event event, const void* data) {
|
||||
emit Update();
|
||||
widget()->setEnabled(true);
|
||||
}
|
||||
@ -289,7 +289,7 @@ void GraphicsSurfaceWidget::Pick(int x, int y) {
|
||||
return;
|
||||
}
|
||||
|
||||
const u8* buffer = memory.GetPhysicalPointer(surface_address);
|
||||
const u8* buffer = system.Memory().GetPhysicalPointer(surface_address);
|
||||
if (!buffer) {
|
||||
surface_info_label->setText(tr("(unable to access pixel data)"));
|
||||
surface_info_label->setAlignment(Qt::AlignCenter);
|
||||
@ -410,13 +410,13 @@ void GraphicsSurfaceWidget::Pick(int x, int y) {
|
||||
void GraphicsSurfaceWidget::OnUpdate() {
|
||||
QPixmap pixmap;
|
||||
|
||||
const auto& regs = system.GPU().PicaCore().regs.internal;
|
||||
switch (surface_source) {
|
||||
case Source::ColorBuffer: {
|
||||
// TODO: Store a reference to the registers in the debug context instead of accessing them
|
||||
// directly...
|
||||
|
||||
const auto& framebuffer = Pica::g_state.regs.framebuffer.framebuffer;
|
||||
|
||||
const auto& framebuffer = regs.framebuffer.framebuffer;
|
||||
surface_address = framebuffer.GetColorBufferPhysicalAddress();
|
||||
surface_width = framebuffer.GetWidth();
|
||||
surface_height = framebuffer.GetHeight();
|
||||
@ -451,8 +451,7 @@ void GraphicsSurfaceWidget::OnUpdate() {
|
||||
}
|
||||
|
||||
case Source::DepthBuffer: {
|
||||
const auto& framebuffer = Pica::g_state.regs.framebuffer.framebuffer;
|
||||
|
||||
const auto& framebuffer = regs.framebuffer.framebuffer;
|
||||
surface_address = framebuffer.GetDepthBufferPhysicalAddress();
|
||||
surface_width = framebuffer.GetWidth();
|
||||
surface_height = framebuffer.GetHeight();
|
||||
@ -479,8 +478,7 @@ void GraphicsSurfaceWidget::OnUpdate() {
|
||||
}
|
||||
|
||||
case Source::StencilBuffer: {
|
||||
const auto& framebuffer = Pica::g_state.regs.framebuffer.framebuffer;
|
||||
|
||||
const auto& framebuffer = regs.framebuffer.framebuffer;
|
||||
surface_address = framebuffer.GetDepthBufferPhysicalAddress();
|
||||
surface_width = framebuffer.GetWidth();
|
||||
surface_height = framebuffer.GetHeight();
|
||||
@ -513,7 +511,7 @@ void GraphicsSurfaceWidget::OnUpdate() {
|
||||
break;
|
||||
}
|
||||
|
||||
const auto texture = Pica::g_state.regs.texturing.GetTextures()[texture_index];
|
||||
const auto texture = regs.texturing.GetTextures()[texture_index];
|
||||
auto info = Pica::Texture::TextureInfo::FromPicaRegister(texture.config, texture.format);
|
||||
|
||||
surface_address = info.physical_address;
|
||||
@ -545,7 +543,7 @@ void GraphicsSurfaceWidget::OnUpdate() {
|
||||
// TODO: Implement a good way to visualize alpha components!
|
||||
|
||||
QImage decoded_image(surface_width, surface_height, QImage::Format_ARGB32);
|
||||
const u8* buffer = memory.GetPhysicalPointer(surface_address);
|
||||
const u8* buffer = system.Memory().GetPhysicalPointer(surface_address);
|
||||
|
||||
if (!buffer) {
|
||||
surface_picture_label->hide();
|
||||
@ -681,7 +679,7 @@ void GraphicsSurfaceWidget::SaveSurface() {
|
||||
tr("Failed to save surface data to file '%1'").arg(filename));
|
||||
}
|
||||
} else if (selected_filter == bin_filter) {
|
||||
const u8* const buffer = memory.GetPhysicalPointer(surface_address);
|
||||
const u8* const buffer = system.Memory().GetPhysicalPointer(surface_address);
|
||||
ASSERT_MSG(buffer, "Memory not accessible");
|
||||
|
||||
QFile file{filename};
|
||||
|
@ -14,8 +14,8 @@ class CSpinBox;
|
||||
|
||||
class GraphicsSurfaceWidget;
|
||||
|
||||
namespace Memory {
|
||||
class MemorySystem;
|
||||
namespace Core {
|
||||
class System;
|
||||
}
|
||||
|
||||
class SurfacePicture : public QLabel {
|
||||
@ -76,7 +76,7 @@ class GraphicsSurfaceWidget : public BreakPointObserverDock {
|
||||
static unsigned int NibblesPerPixel(Format format);
|
||||
|
||||
public:
|
||||
explicit GraphicsSurfaceWidget(Memory::MemorySystem& memory,
|
||||
explicit GraphicsSurfaceWidget(Core::System& system,
|
||||
std::shared_ptr<Pica::DebugContext> debug_context,
|
||||
QWidget* parent = nullptr);
|
||||
void Pick(int x, int y);
|
||||
@ -95,12 +95,12 @@ signals:
|
||||
void Update();
|
||||
|
||||
private:
|
||||
void OnBreakPointHit(Pica::DebugContext::Event event, void* data) override;
|
||||
void OnBreakPointHit(Pica::DebugContext::Event event, const void* data) override;
|
||||
void OnResumed() override;
|
||||
|
||||
void SaveSurface();
|
||||
|
||||
Memory::MemorySystem& memory;
|
||||
Core::System& system;
|
||||
QComboBox* surface_source_list;
|
||||
CSpinBox* surface_address_control;
|
||||
QSpinBox* surface_width_control;
|
||||
|
@ -14,14 +14,15 @@
|
||||
#include <nihstro/float24.h>
|
||||
#include "citra_qt/debugger/graphics/graphics_tracing.h"
|
||||
#include "common/common_types.h"
|
||||
#include "core/hw/gpu.h"
|
||||
#include "core/hw/lcd.h"
|
||||
#include "core/core.h"
|
||||
#include "core/tracer/recorder.h"
|
||||
#include "video_core/pica_state.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/pica/pica_core.h"
|
||||
|
||||
GraphicsTracingWidget::GraphicsTracingWidget(std::shared_ptr<Pica::DebugContext> debug_context,
|
||||
GraphicsTracingWidget::GraphicsTracingWidget(Core::System& system_,
|
||||
std::shared_ptr<Pica::DebugContext> debug_context,
|
||||
QWidget* parent)
|
||||
: BreakPointObserverDock(debug_context, tr("CiTrace Recorder"), parent) {
|
||||
: BreakPointObserverDock(debug_context, tr("CiTrace Recorder"), parent), system{system_} {
|
||||
|
||||
setObjectName(QStringLiteral("CiTracing"));
|
||||
|
||||
@ -61,45 +62,46 @@ void GraphicsTracingWidget::StartRecording() {
|
||||
if (!context)
|
||||
return;
|
||||
|
||||
auto shader_binary = Pica::g_state.vs.program_code;
|
||||
auto swizzle_data = Pica::g_state.vs.swizzle_data;
|
||||
auto& pica = system.GPU().PicaCore();
|
||||
auto shader_binary = pica.vs_setup.program_code;
|
||||
auto swizzle_data = pica.vs_setup.swizzle_data;
|
||||
|
||||
// Encode floating point numbers to 24-bit values
|
||||
// TODO: Drop this explicit conversion once we store float24 values bit-correctly internally.
|
||||
std::array<u32, 4 * 16> default_attributes;
|
||||
for (unsigned i = 0; i < 16; ++i) {
|
||||
for (unsigned comp = 0; comp < 3; ++comp) {
|
||||
default_attributes[4 * i + comp] = nihstro::to_float24(
|
||||
Pica::g_state.input_default_attributes.attr[i][comp].ToFloat32());
|
||||
for (u32 i = 0; i < 16; ++i) {
|
||||
for (u32 comp = 0; comp < 3; ++comp) {
|
||||
default_attributes[4 * i + comp] =
|
||||
nihstro::to_float24(pica.input_default_attributes[i][comp].ToFloat32());
|
||||
}
|
||||
}
|
||||
|
||||
std::array<u32, 4 * 96> vs_float_uniforms;
|
||||
for (unsigned i = 0; i < 96; ++i)
|
||||
for (unsigned comp = 0; comp < 3; ++comp)
|
||||
for (u32 i = 0; i < 96; ++i) {
|
||||
for (u32 comp = 0; comp < 3; ++comp) {
|
||||
vs_float_uniforms[4 * i + comp] =
|
||||
nihstro::to_float24(Pica::g_state.vs.uniforms.f[i][comp].ToFloat32());
|
||||
nihstro::to_float24(pica.vs_setup.uniforms.f[i][comp].ToFloat32());
|
||||
}
|
||||
}
|
||||
|
||||
CiTrace::Recorder::InitialState state;
|
||||
std::copy_n((u32*)&GPU::g_regs, sizeof(GPU::g_regs) / sizeof(u32),
|
||||
std::back_inserter(state.gpu_registers));
|
||||
std::copy_n((u32*)&LCD::g_regs, sizeof(LCD::g_regs) / sizeof(u32),
|
||||
std::back_inserter(state.lcd_registers));
|
||||
std::copy_n((u32*)&Pica::g_state.regs, sizeof(Pica::g_state.regs) / sizeof(u32),
|
||||
std::back_inserter(state.pica_registers));
|
||||
std::copy(default_attributes.begin(), default_attributes.end(),
|
||||
std::back_inserter(state.default_attributes));
|
||||
std::copy(shader_binary.begin(), shader_binary.end(),
|
||||
std::back_inserter(state.vs_program_binary));
|
||||
std::copy(swizzle_data.begin(), swizzle_data.end(), std::back_inserter(state.vs_swizzle_data));
|
||||
std::copy(vs_float_uniforms.begin(), vs_float_uniforms.end(),
|
||||
std::back_inserter(state.vs_float_uniforms));
|
||||
// boost::copy(TODO: Not implemented, std::back_inserter(state.gs_program_binary));
|
||||
// boost::copy(TODO: Not implemented, std::back_inserter(state.gs_swizzle_data));
|
||||
// boost::copy(TODO: Not implemented, std::back_inserter(state.gs_float_uniforms));
|
||||
|
||||
auto recorder = new CiTrace::Recorder(state);
|
||||
context->recorder = std::shared_ptr<CiTrace::Recorder>(recorder);
|
||||
const auto copy = [&](std::vector<u32>& dest, auto& data) {
|
||||
dest.resize(sizeof(data));
|
||||
std::memcpy(dest.data(), std::addressof(data), sizeof(data));
|
||||
};
|
||||
|
||||
copy(state.pica_registers, pica.regs);
|
||||
copy(state.lcd_registers, pica.regs_lcd);
|
||||
copy(state.default_attributes, default_attributes);
|
||||
copy(state.vs_program_binary, shader_binary);
|
||||
copy(state.vs_swizzle_data, swizzle_data);
|
||||
copy(state.vs_float_uniforms, vs_float_uniforms);
|
||||
// copy(TODO: Not implemented, std::back_inserter(state.gs_program_binary));
|
||||
// copy(TODO: Not implemented, std::back_inserter(state.gs_swizzle_data));
|
||||
// copy(TODO: Not implemented, std::back_inserter(state.gs_float_uniforms));
|
||||
|
||||
context->recorder = std::make_shared<CiTrace::Recorder>(state);
|
||||
|
||||
emit SetStartTracingButtonEnabled(false);
|
||||
emit SetStopTracingButtonEnabled(true);
|
||||
@ -139,7 +141,7 @@ void GraphicsTracingWidget::AbortRecording() {
|
||||
emit SetStartTracingButtonEnabled(true);
|
||||
}
|
||||
|
||||
void GraphicsTracingWidget::OnBreakPointHit(Pica::DebugContext::Event event, void* data) {
|
||||
void GraphicsTracingWidget::OnBreakPointHit(Pica::DebugContext::Event event, const void* data) {
|
||||
widget()->setEnabled(true);
|
||||
}
|
||||
|
||||
|
@ -6,13 +6,18 @@
|
||||
|
||||
#include "citra_qt/debugger/graphics/graphics_breakpoint_observer.h"
|
||||
|
||||
namespace Core {
|
||||
class System;
|
||||
}
|
||||
|
||||
class EmuThread;
|
||||
|
||||
class GraphicsTracingWidget : public BreakPointObserverDock {
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
explicit GraphicsTracingWidget(std::shared_ptr<Pica::DebugContext> debug_context,
|
||||
explicit GraphicsTracingWidget(Core::System& system,
|
||||
std::shared_ptr<Pica::DebugContext> debug_context,
|
||||
QWidget* parent = nullptr);
|
||||
|
||||
void OnEmulationStarting(EmuThread* emu_thread);
|
||||
@ -23,11 +28,14 @@ private slots:
|
||||
void StopRecording();
|
||||
void AbortRecording();
|
||||
|
||||
void OnBreakPointHit(Pica::DebugContext::Event event, void* data) override;
|
||||
void OnBreakPointHit(Pica::DebugContext::Event event, const void* data) override;
|
||||
void OnResumed() override;
|
||||
|
||||
signals:
|
||||
void SetStartTracingButtonEnabled(bool enable);
|
||||
void SetStopTracingButtonEnabled(bool enable);
|
||||
void SetAbortTracingButtonEnabled(bool enable);
|
||||
|
||||
private:
|
||||
Core::System& system;
|
||||
};
|
||||
|
@ -16,9 +16,9 @@
|
||||
#include <QTreeView>
|
||||
#include "citra_qt/debugger/graphics/graphics_vertex_shader.h"
|
||||
#include "citra_qt/util/util.h"
|
||||
#include "video_core/pica_state.h"
|
||||
#include "video_core/shader/debug_data.h"
|
||||
#include "video_core/shader/shader.h"
|
||||
#include "core/core.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/pica/pica_core.h"
|
||||
#include "video_core/shader/shader_interpreter.h"
|
||||
|
||||
using nihstro::Instruction;
|
||||
@ -352,16 +352,14 @@ void GraphicsVertexShaderWidget::DumpShader() {
|
||||
return;
|
||||
}
|
||||
|
||||
auto& setup = Pica::g_state.vs;
|
||||
auto& config = Pica::g_state.regs.vs;
|
||||
|
||||
Pica::DebugUtils::DumpShader(filename.toStdString(), config, setup,
|
||||
Pica::g_state.regs.rasterizer.vs_output_attributes);
|
||||
auto& pica = system.GPU().PicaCore();
|
||||
Pica::DebugUtils::DumpShader(filename.toStdString(), pica.regs.internal.vs, pica.vs_setup,
|
||||
pica.regs.internal.rasterizer.vs_output_attributes);
|
||||
}
|
||||
|
||||
GraphicsVertexShaderWidget::GraphicsVertexShaderWidget(
|
||||
std::shared_ptr<Pica::DebugContext> debug_context, QWidget* parent)
|
||||
: BreakPointObserverDock(debug_context, tr("Pica Vertex Shader"), parent) {
|
||||
Core::System& system_, std::shared_ptr<Pica::DebugContext> debug_context, QWidget* parent)
|
||||
: BreakPointObserverDock(debug_context, tr("Pica Vertex Shader"), parent), system{system_} {
|
||||
setObjectName(QStringLiteral("PicaVertexShader"));
|
||||
|
||||
// Clear input vertex data so that it contains valid float values in case a debug shader
|
||||
@ -472,7 +470,8 @@ GraphicsVertexShaderWidget::GraphicsVertexShaderWidget(
|
||||
widget()->setEnabled(false);
|
||||
}
|
||||
|
||||
void GraphicsVertexShaderWidget::OnBreakPointHit(Pica::DebugContext::Event event, void* data) {
|
||||
void GraphicsVertexShaderWidget::OnBreakPointHit(Pica::DebugContext::Event event,
|
||||
const void* data) {
|
||||
if (event == Pica::DebugContext::Event::VertexShaderInvocation) {
|
||||
Reload(true, data);
|
||||
} else {
|
||||
@ -482,7 +481,7 @@ void GraphicsVertexShaderWidget::OnBreakPointHit(Pica::DebugContext::Event event
|
||||
widget()->setEnabled(true);
|
||||
}
|
||||
|
||||
void GraphicsVertexShaderWidget::Reload(bool replace_vertex_data, void* vertex_data) {
|
||||
void GraphicsVertexShaderWidget::Reload(bool replace_vertex_data, const void* vertex_data) {
|
||||
model->beginResetModel();
|
||||
|
||||
if (replace_vertex_data) {
|
||||
@ -491,7 +490,7 @@ void GraphicsVertexShaderWidget::Reload(bool replace_vertex_data, void* vertex_d
|
||||
for (unsigned attr = 0; attr < 16; ++attr) {
|
||||
for (unsigned comp = 0; comp < 4; ++comp) {
|
||||
input_data[4 * attr + comp]->setText(
|
||||
QStringLiteral("%1").arg(input_vertex.attr[attr][comp].ToFloat32()));
|
||||
QStringLiteral("%1").arg(input_vertex[attr][comp].ToFloat32()));
|
||||
}
|
||||
}
|
||||
breakpoint_warning->hide();
|
||||
@ -508,28 +507,27 @@ void GraphicsVertexShaderWidget::Reload(bool replace_vertex_data, void* vertex_d
|
||||
// Reload shader code
|
||||
info.Clear();
|
||||
|
||||
auto& shader_setup = Pica::g_state.vs;
|
||||
auto& shader_config = Pica::g_state.regs.vs;
|
||||
for (auto instr : shader_setup.program_code)
|
||||
auto& pica = system.GPU().PicaCore();
|
||||
for (auto instr : pica.vs_setup.program_code)
|
||||
info.code.push_back({instr});
|
||||
int num_attributes = shader_config.max_input_attribute_index + 1;
|
||||
int num_attributes = pica.regs.internal.vs.max_input_attribute_index + 1;
|
||||
|
||||
for (auto pattern : shader_setup.swizzle_data) {
|
||||
for (auto pattern : pica.vs_setup.swizzle_data) {
|
||||
const nihstro::SwizzleInfo swizzle_info = {.pattern = nihstro::SwizzlePattern{pattern}};
|
||||
info.swizzle_info.push_back(swizzle_info);
|
||||
}
|
||||
|
||||
u32 entry_point = Pica::g_state.regs.vs.main_offset;
|
||||
u32 entry_point = pica.regs.internal.vs.main_offset;
|
||||
info.labels.insert({entry_point, "main"});
|
||||
|
||||
// Generate debug information
|
||||
Pica::Shader::InterpreterEngine shader_engine;
|
||||
shader_engine.SetupBatch(shader_setup, entry_point);
|
||||
debug_data = shader_engine.ProduceDebugInfo(shader_setup, input_vertex, shader_config);
|
||||
shader_engine.SetupBatch(pica.vs_setup, entry_point);
|
||||
debug_data = shader_engine.ProduceDebugInfo(pica.vs_setup, input_vertex, pica.regs.internal.vs);
|
||||
|
||||
// Reload widget state
|
||||
for (int attr = 0; attr < num_attributes; ++attr) {
|
||||
unsigned source_attr = shader_config.GetRegisterForAttribute(attr);
|
||||
unsigned source_attr = pica.regs.internal.vs.GetRegisterForAttribute(attr);
|
||||
input_data_mapping[attr]->setText(QStringLiteral("-> v%1").arg(source_attr));
|
||||
input_data_container[attr]->setVisible(true);
|
||||
}
|
||||
@ -551,7 +549,7 @@ void GraphicsVertexShaderWidget::OnResumed() {
|
||||
|
||||
void GraphicsVertexShaderWidget::OnInputAttributeChanged(int index) {
|
||||
const f32 value = input_data[index]->text().toFloat();
|
||||
input_vertex.attr[index / 4][index % 4] = Pica::f24::FromFloat32(value);
|
||||
input_vertex[index / 4][index % 4] = Pica::f24::FromFloat32(value);
|
||||
// Re-execute shader with updated value
|
||||
Reload();
|
||||
}
|
||||
|
@ -8,8 +8,12 @@
|
||||
#include <QTreeView>
|
||||
#include <nihstro/parser_shbin.h>
|
||||
#include "citra_qt/debugger/graphics/graphics_breakpoint_observer.h"
|
||||
#include "video_core/pica/output_vertex.h"
|
||||
#include "video_core/shader/debug_data.h"
|
||||
#include "video_core/shader/shader.h"
|
||||
|
||||
namespace Core {
|
||||
class System;
|
||||
}
|
||||
|
||||
class QLabel;
|
||||
class QSpinBox;
|
||||
@ -40,11 +44,12 @@ class GraphicsVertexShaderWidget : public BreakPointObserverDock {
|
||||
using Event = Pica::DebugContext::Event;
|
||||
|
||||
public:
|
||||
GraphicsVertexShaderWidget(std::shared_ptr<Pica::DebugContext> debug_context,
|
||||
GraphicsVertexShaderWidget(Core::System& system,
|
||||
std::shared_ptr<Pica::DebugContext> debug_context,
|
||||
QWidget* parent = nullptr);
|
||||
|
||||
private slots:
|
||||
void OnBreakPointHit(Pica::DebugContext::Event event, void* data) override;
|
||||
void OnBreakPointHit(Pica::DebugContext::Event event, const void* data) override;
|
||||
void OnResumed() override;
|
||||
|
||||
void OnInputAttributeChanged(int index);
|
||||
@ -60,9 +65,10 @@ private slots:
|
||||
* specify that no valid vertex data can be retrieved currently. Only used if
|
||||
* replace_vertex_data is true.
|
||||
*/
|
||||
void Reload(bool replace_vertex_data = false, void* vertex_data = nullptr);
|
||||
void Reload(bool replace_vertex_data = false, const void* vertex_data = nullptr);
|
||||
|
||||
private:
|
||||
Core::System& system;
|
||||
QLabel* instruction_description;
|
||||
QTreeView* binary_list;
|
||||
GraphicsVertexShaderModel* model;
|
||||
@ -83,7 +89,7 @@ private:
|
||||
|
||||
nihstro::ShaderInfo info;
|
||||
Pica::Shader::DebugData<true> debug_data;
|
||||
Pica::Shader::AttributeBuffer input_vertex;
|
||||
Pica::AttributeBuffer input_vertex;
|
||||
|
||||
friend class GraphicsVertexShaderModel;
|
||||
};
|
||||
|
@ -49,7 +49,7 @@ QString IPCRecorderWidget::GetStatusStr(const IPCDebugger::RequestRecord& record
|
||||
case IPCDebugger::RequestStatus::Handling:
|
||||
return tr("Handling");
|
||||
case IPCDebugger::RequestStatus::Handled:
|
||||
if (record.translated_reply_cmdbuf[1] == RESULT_SUCCESS.raw) {
|
||||
if (record.translated_reply_cmdbuf[1] == ResultSuccess.raw) {
|
||||
return tr("Success");
|
||||
}
|
||||
return tr("Error");
|
||||
@ -88,7 +88,7 @@ void IPCRecorderWidget::OnEntryUpdated(IPCDebugger::RequestRecord record) {
|
||||
|
||||
if (record.status == IPCDebugger::RequestStatus::HLEUnimplemented ||
|
||||
(record.status == IPCDebugger::RequestStatus::Handled &&
|
||||
record.translated_reply_cmdbuf[1] != RESULT_SUCCESS.raw)) { // Unimplemented / Error
|
||||
record.translated_reply_cmdbuf[1] != ResultSuccess.raw)) { // Unimplemented / Error
|
||||
|
||||
auto item = ui->main->invisibleRootItem()->child(row_id);
|
||||
for (int column = 0; column < item->columnCount(); ++column) {
|
||||
|
@ -74,7 +74,6 @@
|
||||
#include "common/logging/backend.h"
|
||||
#include "common/logging/log.h"
|
||||
#include "common/memory_detect.h"
|
||||
#include "common/microprofile.h"
|
||||
#include "common/scm_rev.h"
|
||||
#include "common/scope_exit.h"
|
||||
#if CITRA_ARCH(x86_64)
|
||||
@ -96,8 +95,8 @@
|
||||
#include "input_common/main.h"
|
||||
#include "network/network_settings.h"
|
||||
#include "ui_main.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/renderer_base.h"
|
||||
#include "video_core/video_core.h"
|
||||
|
||||
#ifdef __APPLE__
|
||||
#include "common/apple_authorization.h"
|
||||
@ -230,6 +229,7 @@ GMainWindow::GMainWindow(Core::System& system_)
|
||||
SetDefaultUIGeometry();
|
||||
RestoreUIState();
|
||||
|
||||
ConnectAppEvents();
|
||||
ConnectMenuEvents();
|
||||
ConnectWidgetEvents();
|
||||
|
||||
@ -458,7 +458,7 @@ void GMainWindow::InitializeDebugWidgets() {
|
||||
connect(this, &GMainWindow::EmulationStopping, registersWidget,
|
||||
&RegistersWidget::OnEmulationStopping);
|
||||
|
||||
graphicsWidget = new GPUCommandStreamWidget(this);
|
||||
graphicsWidget = new GPUCommandStreamWidget(system, this);
|
||||
addDockWidget(Qt::RightDockWidgetArea, graphicsWidget);
|
||||
graphicsWidget->hide();
|
||||
debug_menu->addAction(graphicsWidget->toggleViewAction());
|
||||
@ -473,12 +473,13 @@ void GMainWindow::InitializeDebugWidgets() {
|
||||
graphicsBreakpointsWidget->hide();
|
||||
debug_menu->addAction(graphicsBreakpointsWidget->toggleViewAction());
|
||||
|
||||
graphicsVertexShaderWidget = new GraphicsVertexShaderWidget(Pica::g_debug_context, this);
|
||||
graphicsVertexShaderWidget =
|
||||
new GraphicsVertexShaderWidget(system, Pica::g_debug_context, this);
|
||||
addDockWidget(Qt::RightDockWidgetArea, graphicsVertexShaderWidget);
|
||||
graphicsVertexShaderWidget->hide();
|
||||
debug_menu->addAction(graphicsVertexShaderWidget->toggleViewAction());
|
||||
|
||||
graphicsTracingWidget = new GraphicsTracingWidget(Pica::g_debug_context, this);
|
||||
graphicsTracingWidget = new GraphicsTracingWidget(system, Pica::g_debug_context, this);
|
||||
addDockWidget(Qt::RightDockWidgetArea, graphicsTracingWidget);
|
||||
graphicsTracingWidget->hide();
|
||||
debug_menu->addAction(graphicsTracingWidget->toggleViewAction());
|
||||
@ -761,6 +762,21 @@ void GMainWindow::OnAppFocusStateChanged(Qt::ApplicationState state) {
|
||||
}
|
||||
}
|
||||
|
||||
bool GApplicationEventFilter::eventFilter(QObject* object, QEvent* event) {
|
||||
if (event->type() == QEvent::FileOpen) {
|
||||
emit FileOpen(static_cast<QFileOpenEvent*>(event));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void GMainWindow::ConnectAppEvents() {
|
||||
const auto filter = new GApplicationEventFilter();
|
||||
QGuiApplication::instance()->installEventFilter(filter);
|
||||
|
||||
connect(filter, &GApplicationEventFilter::FileOpen, this, &GMainWindow::OnFileOpen);
|
||||
}
|
||||
|
||||
void GMainWindow::ConnectWidgetEvents() {
|
||||
connect(game_list, &GameList::GameChosen, this, &GMainWindow::OnGameListLoadFile);
|
||||
connect(game_list, &GameList::OpenDirectory, this, &GMainWindow::OnGameListOpenDirectory);
|
||||
@ -1237,6 +1253,11 @@ void GMainWindow::BootGame(const QString& filename) {
|
||||
video_dumping_path.clear();
|
||||
}
|
||||
|
||||
// Register debug widgets
|
||||
if (graphicsWidget->isVisible()) {
|
||||
graphicsWidget->Register();
|
||||
}
|
||||
|
||||
// Create and start the emulation thread
|
||||
emu_thread = std::make_unique<EmuThread>(system, *render_window);
|
||||
emit EmulationStarting(emu_thread.get());
|
||||
@ -1315,6 +1336,11 @@ void GMainWindow::ShutdownGame() {
|
||||
// TODO(bunnei): This function is not thread safe, but it's being used as if it were
|
||||
Pica::g_debug_context->ClearBreakpoints();
|
||||
|
||||
// Unregister debug widgets
|
||||
if (graphicsWidget->isVisible()) {
|
||||
graphicsWidget->Unregister();
|
||||
}
|
||||
|
||||
// Frame advancing must be cancelled in order to release the emu thread from waiting
|
||||
system.frame_limiter.SetFrameAdvancing(false);
|
||||
|
||||
@ -2214,7 +2240,7 @@ void GMainWindow::OnToggleFilterBar() {
|
||||
|
||||
void GMainWindow::OnCreateGraphicsSurfaceViewer() {
|
||||
auto graphicsSurfaceViewerWidget =
|
||||
new GraphicsSurfaceWidget(system.Memory(), Pica::g_debug_context, this);
|
||||
new GraphicsSurfaceWidget(system, Pica::g_debug_context, this);
|
||||
addDockWidget(Qt::RightDockWidgetArea, graphicsSurfaceViewerWidget);
|
||||
// TODO: Maybe graphicsSurfaceViewerWidget->setFloating(true);
|
||||
graphicsSurfaceViewerWidget->show();
|
||||
@ -2434,10 +2460,10 @@ void GMainWindow::OnStartVideoDumping() {
|
||||
}
|
||||
|
||||
void GMainWindow::StartVideoDumping(const QString& path) {
|
||||
Layout::FramebufferLayout layout{
|
||||
Layout::FrameLayoutFromResolutionScale(VideoCore::g_renderer->GetResolutionScaleFactor())};
|
||||
auto& renderer = system.GPU().Renderer();
|
||||
const auto layout{Layout::FrameLayoutFromResolutionScale(renderer.GetResolutionScaleFactor())};
|
||||
|
||||
auto dumper = std::make_shared<VideoDumper::FFmpegBackend>();
|
||||
auto dumper = std::make_shared<VideoDumper::FFmpegBackend>(renderer);
|
||||
if (dumper->StartDumping(path.toStdString(), layout)) {
|
||||
system.RegisterVideoDumper(dumper);
|
||||
} else {
|
||||
@ -2742,6 +2768,10 @@ bool GMainWindow::DropAction(QDropEvent* event) {
|
||||
return true;
|
||||
}
|
||||
|
||||
void GMainWindow::OnFileOpen(const QFileOpenEvent* event) {
|
||||
BootGame(event->file());
|
||||
}
|
||||
|
||||
void GMainWindow::dropEvent(QDropEvent* event) {
|
||||
DropAction(event);
|
||||
}
|
||||
|
@ -41,6 +41,7 @@ class LoadingScreen;
|
||||
class MicroProfileDialog;
|
||||
class MultiplayerState;
|
||||
class ProfilerWidget;
|
||||
class QFileOpenEvent;
|
||||
template <typename>
|
||||
class QFutureWatcher;
|
||||
class QLabel;
|
||||
@ -96,6 +97,8 @@ public:
|
||||
bool DropAction(QDropEvent* event);
|
||||
void AcceptDropEvent(QDropEvent* event);
|
||||
|
||||
void OnFileOpen(const QFileOpenEvent* event);
|
||||
|
||||
void UninstallTitles(
|
||||
const std::vector<std::tuple<Service::FS::MediaType, u64, QString>>& titles);
|
||||
|
||||
@ -137,6 +140,7 @@ private:
|
||||
void SyncMenuUISettings();
|
||||
void RestoreUIState();
|
||||
|
||||
void ConnectAppEvents();
|
||||
void ConnectWidgetEvents();
|
||||
void ConnectMenuEvents();
|
||||
void UpdateMenuState();
|
||||
@ -382,5 +386,15 @@ protected:
|
||||
void mouseReleaseEvent(QMouseEvent* event) override;
|
||||
};
|
||||
|
||||
class GApplicationEventFilter : public QObject {
|
||||
Q_OBJECT
|
||||
|
||||
signals:
|
||||
void FileOpen(const QFileOpenEvent* event);
|
||||
|
||||
protected:
|
||||
bool eventFilter(QObject* object, QEvent* event) override;
|
||||
};
|
||||
|
||||
Q_DECLARE_METATYPE(std::size_t);
|
||||
Q_DECLARE_METATYPE(Service::AM::InstallStatus);
|
||||
|
@ -37,16 +37,14 @@ add_custom_command(OUTPUT scm_rev.cpp
|
||||
"${VIDEO_CORE}/shader/generator/spv_fs_shader_gen.h"
|
||||
"${VIDEO_CORE}/shader/shader.cpp"
|
||||
"${VIDEO_CORE}/shader/shader.h"
|
||||
"${VIDEO_CORE}/pica.cpp"
|
||||
"${VIDEO_CORE}/pica.h"
|
||||
"${VIDEO_CORE}/regs_framebuffer.h"
|
||||
"${VIDEO_CORE}/regs_lighting.h"
|
||||
"${VIDEO_CORE}/regs_pipeline.h"
|
||||
"${VIDEO_CORE}/regs_rasterizer.h"
|
||||
"${VIDEO_CORE}/regs_shader.h"
|
||||
"${VIDEO_CORE}/regs_texturing.h"
|
||||
"${VIDEO_CORE}/regs.cpp"
|
||||
"${VIDEO_CORE}/regs.h"
|
||||
"${VIDEO_CORE}/pica/regs_framebuffer.h"
|
||||
"${VIDEO_CORE}/pica/regs_lighting.h"
|
||||
"${VIDEO_CORE}/pica/regs_pipeline.h"
|
||||
"${VIDEO_CORE}/pica/regs_rasterizer.h"
|
||||
"${VIDEO_CORE}/pica/regs_shader.h"
|
||||
"${VIDEO_CORE}/pica/regs_texturing.h"
|
||||
"${VIDEO_CORE}/pica/regs_internal.cpp"
|
||||
"${VIDEO_CORE}/pica/regs_internal.h"
|
||||
# and also check that the scm_rev files haven't changed
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h"
|
||||
|
@ -110,8 +110,10 @@ public:
|
||||
return std::span{cptr, std::min(size, csize)};
|
||||
}
|
||||
|
||||
std::span<const u8> GetReadBytes(std::size_t size) const {
|
||||
return std::span{cptr, std::min(size, csize)};
|
||||
template <typename T>
|
||||
std::span<const T> GetReadBytes(std::size_t size) const {
|
||||
const auto* cptr_t = reinterpret_cast<T*>(cptr);
|
||||
return std::span{cptr_t, std::min(size, csize) / sizeof(T)};
|
||||
}
|
||||
|
||||
std::size_t GetSize() const {
|
||||
|
@ -299,8 +299,10 @@ add_library(citra_core STATIC
|
||||
hle/service/fs/fs_user.h
|
||||
hle/service/gsp/gsp.cpp
|
||||
hle/service/gsp/gsp.h
|
||||
hle/service/gsp/gsp_command.h
|
||||
hle/service/gsp/gsp_gpu.cpp
|
||||
hle/service/gsp/gsp_gpu.h
|
||||
hle/service/gsp/gsp_interrupt.h
|
||||
hle/service/gsp/gsp_lcd.cpp
|
||||
hle/service/gsp/gsp_lcd.h
|
||||
hle/service/hid/hid.cpp
|
||||
@ -433,12 +435,6 @@ add_library(citra_core STATIC
|
||||
hw/aes/ccm.h
|
||||
hw/aes/key.cpp
|
||||
hw/aes/key.h
|
||||
hw/gpu.cpp
|
||||
hw/gpu.h
|
||||
hw/hw.cpp
|
||||
hw/hw.h
|
||||
hw/lcd.cpp
|
||||
hw/lcd.h
|
||||
hw/rsa/rsa.cpp
|
||||
hw/rsa/rsa.h
|
||||
hw/y2r.cpp
|
||||
|
@ -10,8 +10,6 @@
|
||||
#include "core/cheats/gateway_cheat.h"
|
||||
#include "core/core.h"
|
||||
#include "core/core_timing.h"
|
||||
#include "core/hle/kernel/process.h"
|
||||
#include "core/hw/gpu.h"
|
||||
|
||||
namespace Cheats {
|
||||
|
||||
@ -19,11 +17,11 @@ namespace Cheats {
|
||||
// we use the same value
|
||||
constexpr u64 run_interval_ticks = 50'000'000;
|
||||
|
||||
CheatEngine::CheatEngine(u64 title_id_, Core::System& system_)
|
||||
: system(system_), title_id{title_id_} {
|
||||
LoadCheatFile();
|
||||
CheatEngine::CheatEngine(Core::System& system_) : system{system_} {}
|
||||
|
||||
CheatEngine::~CheatEngine() {
|
||||
if (system.IsPoweredOn()) {
|
||||
Connect();
|
||||
system.CoreTiming().UnscheduleEvent(event, 0);
|
||||
}
|
||||
}
|
||||
|
||||
@ -34,24 +32,18 @@ void CheatEngine::Connect() {
|
||||
system.CoreTiming().ScheduleEvent(run_interval_ticks, event);
|
||||
}
|
||||
|
||||
CheatEngine::~CheatEngine() {
|
||||
if (system.IsPoweredOn()) {
|
||||
system.CoreTiming().UnscheduleEvent(event, 0);
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<CheatBase>> CheatEngine::GetCheats() const {
|
||||
std::shared_lock<std::shared_mutex> lock(cheats_list_mutex);
|
||||
std::span<const std::shared_ptr<CheatBase>> CheatEngine::GetCheats() const {
|
||||
std::shared_lock lock{cheats_list_mutex};
|
||||
return cheats_list;
|
||||
}
|
||||
|
||||
void CheatEngine::AddCheat(const std::shared_ptr<CheatBase>& cheat) {
|
||||
std::unique_lock<std::shared_mutex> lock(cheats_list_mutex);
|
||||
cheats_list.push_back(cheat);
|
||||
void CheatEngine::AddCheat(std::shared_ptr<CheatBase>&& cheat) {
|
||||
std::unique_lock lock{cheats_list_mutex};
|
||||
cheats_list.push_back(std::move(cheat));
|
||||
}
|
||||
|
||||
void CheatEngine::RemoveCheat(std::size_t index) {
|
||||
std::unique_lock<std::shared_mutex> lock(cheats_list_mutex);
|
||||
std::unique_lock lock{cheats_list_mutex};
|
||||
if (index < 0 || index >= cheats_list.size()) {
|
||||
LOG_ERROR(Core_Cheats, "Invalid index {}", index);
|
||||
return;
|
||||
@ -59,16 +51,16 @@ void CheatEngine::RemoveCheat(std::size_t index) {
|
||||
cheats_list.erase(cheats_list.begin() + index);
|
||||
}
|
||||
|
||||
void CheatEngine::UpdateCheat(std::size_t index, const std::shared_ptr<CheatBase>& new_cheat) {
|
||||
std::unique_lock<std::shared_mutex> lock(cheats_list_mutex);
|
||||
void CheatEngine::UpdateCheat(std::size_t index, std::shared_ptr<CheatBase>&& new_cheat) {
|
||||
std::unique_lock lock{cheats_list_mutex};
|
||||
if (index < 0 || index >= cheats_list.size()) {
|
||||
LOG_ERROR(Core_Cheats, "Invalid index {}", index);
|
||||
return;
|
||||
}
|
||||
cheats_list[index] = new_cheat;
|
||||
cheats_list[index] = std::move(new_cheat);
|
||||
}
|
||||
|
||||
void CheatEngine::SaveCheatFile() const {
|
||||
void CheatEngine::SaveCheatFile(u64 title_id) const {
|
||||
const std::string cheat_dir = FileUtil::GetUserPath(FileUtil::UserPath::CheatsDir);
|
||||
const std::string filepath = fmt::format("{}{:016X}.txt", cheat_dir, title_id);
|
||||
|
||||
@ -83,7 +75,14 @@ void CheatEngine::SaveCheatFile() const {
|
||||
}
|
||||
}
|
||||
|
||||
void CheatEngine::LoadCheatFile() {
|
||||
void CheatEngine::LoadCheatFile(u64 title_id) {
|
||||
{
|
||||
std::unique_lock lock{cheats_list_mutex};
|
||||
if (loaded_title_id.has_value() && loaded_title_id == title_id) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
const std::string cheat_dir = FileUtil::GetUserPath(FileUtil::UserPath::CheatsDir);
|
||||
const std::string filepath = fmt::format("{}{:016X}.txt", cheat_dir, title_id);
|
||||
|
||||
@ -91,20 +90,22 @@ void CheatEngine::LoadCheatFile() {
|
||||
FileUtil::CreateDir(cheat_dir);
|
||||
}
|
||||
|
||||
if (!FileUtil::Exists(filepath))
|
||||
if (!FileUtil::Exists(filepath)) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto gateway_cheats = GatewayCheat::LoadFile(filepath);
|
||||
{
|
||||
std::unique_lock<std::shared_mutex> lock(cheats_list_mutex);
|
||||
std::move(gateway_cheats.begin(), gateway_cheats.end(), std::back_inserter(cheats_list));
|
||||
std::unique_lock lock{cheats_list_mutex};
|
||||
loaded_title_id = title_id;
|
||||
cheats_list = std::move(gateway_cheats);
|
||||
}
|
||||
}
|
||||
|
||||
void CheatEngine::RunCallback([[maybe_unused]] std::uintptr_t user_data, s64 cycles_late) {
|
||||
{
|
||||
std::shared_lock<std::shared_mutex> lock(cheats_list_mutex);
|
||||
for (auto& cheat : cheats_list) {
|
||||
std::shared_lock lock{cheats_list_mutex};
|
||||
for (const auto& cheat : cheats_list) {
|
||||
if (cheat->IsEnabled()) {
|
||||
cheat->Execute(system);
|
||||
}
|
||||
|
@ -5,7 +5,9 @@
|
||||
#pragma once
|
||||
|
||||
#include <memory>
|
||||
#include <optional>
|
||||
#include <shared_mutex>
|
||||
#include <span>
|
||||
#include <vector>
|
||||
#include "common/common_types.h"
|
||||
|
||||
@ -24,22 +26,39 @@ class CheatBase;
|
||||
|
||||
class CheatEngine {
|
||||
public:
|
||||
explicit CheatEngine(u64 title_id_, Core::System& system);
|
||||
explicit CheatEngine(Core::System& system);
|
||||
~CheatEngine();
|
||||
|
||||
/// Registers the cheat execution callback.
|
||||
void Connect();
|
||||
std::vector<std::shared_ptr<CheatBase>> GetCheats() const;
|
||||
void AddCheat(const std::shared_ptr<CheatBase>& cheat);
|
||||
|
||||
/// Returns a span of the currently active cheats.
|
||||
std::span<const std::shared_ptr<CheatBase>> GetCheats() const;
|
||||
|
||||
/// Adds a cheat to the cheat engine.
|
||||
void AddCheat(std::shared_ptr<CheatBase>&& cheat);
|
||||
|
||||
/// Removes a cheat at the specified index in the cheats list.
|
||||
void RemoveCheat(std::size_t index);
|
||||
void UpdateCheat(std::size_t index, const std::shared_ptr<CheatBase>& new_cheat);
|
||||
void SaveCheatFile() const;
|
||||
|
||||
/// Updates a cheat at the specified index in the cheats list.
|
||||
void UpdateCheat(std::size_t index, std::shared_ptr<CheatBase>&& new_cheat);
|
||||
|
||||
/// Loads the cheat file from disk for the specified title id.
|
||||
void LoadCheatFile(u64 title_id);
|
||||
|
||||
/// Saves currently active cheats to file for the specified title id.
|
||||
void SaveCheatFile(u64 title_id) const;
|
||||
|
||||
private:
|
||||
void LoadCheatFile();
|
||||
/// The cheat execution callback.
|
||||
void RunCallback(std::uintptr_t user_data, s64 cycles_late);
|
||||
|
||||
private:
|
||||
Core::System& system;
|
||||
Core::TimingEventType* event;
|
||||
std::optional<u64> loaded_title_id;
|
||||
std::vector<std::shared_ptr<CheatBase>> cheats_list;
|
||||
mutable std::shared_mutex cheats_list_mutex;
|
||||
Core::TimingEventType* event;
|
||||
Core::System& system;
|
||||
u64 title_id;
|
||||
};
|
||||
} // namespace Cheats
|
||||
|
@ -472,8 +472,8 @@ std::string GatewayCheat::ToString() const {
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<std::unique_ptr<CheatBase>> GatewayCheat::LoadFile(const std::string& filepath) {
|
||||
std::vector<std::unique_ptr<CheatBase>> cheats;
|
||||
std::vector<std::shared_ptr<CheatBase>> GatewayCheat::LoadFile(const std::string& filepath) {
|
||||
std::vector<std::shared_ptr<CheatBase>> cheats;
|
||||
|
||||
boost::iostreams::stream<boost::iostreams::file_descriptor_source> file;
|
||||
FileUtil::OpenFStream<std::ios_base::in>(file, filepath);
|
||||
@ -493,7 +493,7 @@ std::vector<std::unique_ptr<CheatBase>> GatewayCheat::LoadFile(const std::string
|
||||
line = Common::StripSpaces(line); // remove spaces at front and end
|
||||
if (line.length() >= 2 && line.front() == '[') {
|
||||
if (!cheat_lines.empty()) {
|
||||
cheats.push_back(std::make_unique<GatewayCheat>(name, cheat_lines, comments));
|
||||
cheats.push_back(std::make_shared<GatewayCheat>(name, cheat_lines, comments));
|
||||
cheats.back()->SetEnabled(enabled);
|
||||
enabled = false;
|
||||
}
|
||||
@ -511,7 +511,7 @@ std::vector<std::unique_ptr<CheatBase>> GatewayCheat::LoadFile(const std::string
|
||||
}
|
||||
}
|
||||
if (!cheat_lines.empty()) {
|
||||
cheats.push_back(std::make_unique<GatewayCheat>(name, cheat_lines, comments));
|
||||
cheats.push_back(std::make_shared<GatewayCheat>(name, cheat_lines, comments));
|
||||
cheats.back()->SetEnabled(enabled);
|
||||
}
|
||||
return cheats;
|
||||
|
@ -77,7 +77,7 @@ public:
|
||||
/// (there might be multiple lines of those hex numbers)
|
||||
/// Comment lines start with a '*'
|
||||
/// This function will pares the file for such structures
|
||||
static std::vector<std::unique_ptr<CheatBase>> LoadFile(const std::string& filepath);
|
||||
static std::vector<std::shared_ptr<CheatBase>> LoadFile(const std::string& filepath);
|
||||
|
||||
private:
|
||||
std::atomic<bool> enabled = false;
|
||||
|
@ -35,14 +35,13 @@
|
||||
#include "core/hle/service/cam/cam.h"
|
||||
#include "core/hle/service/fs/archive.h"
|
||||
#include "core/hle/service/gsp/gsp.h"
|
||||
#include "core/hle/service/gsp/gsp_gpu.h"
|
||||
#include "core/hle/service/ir/ir_rst.h"
|
||||
#include "core/hle/service/mic/mic_u.h"
|
||||
#include "core/hle/service/plgldr/plgldr.h"
|
||||
#include "core/hle/service/service.h"
|
||||
#include "core/hle/service/sm/sm.h"
|
||||
#include "core/hw/gpu.h"
|
||||
#include "core/hw/hw.h"
|
||||
#include "core/hw/lcd.h"
|
||||
#include "core/hw/aes/key.h"
|
||||
#include "core/loader/loader.h"
|
||||
#include "core/movie.h"
|
||||
#ifdef ENABLE_SCRIPTING
|
||||
@ -51,8 +50,8 @@
|
||||
#include "core/telemetry_session.h"
|
||||
#include "network/network.h"
|
||||
#include "video_core/custom_textures/custom_tex_manager.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/renderer_base.h"
|
||||
#include "video_core/video_core.h"
|
||||
|
||||
namespace Core {
|
||||
|
||||
@ -73,7 +72,7 @@ Core::Timing& Global() {
|
||||
return System::GetInstance().CoreTiming();
|
||||
}
|
||||
|
||||
System::System() : movie{*this} {}
|
||||
System::System() : movie{*this}, cheat_engine{*this} {}
|
||||
|
||||
System::~System() = default;
|
||||
|
||||
@ -235,7 +234,6 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
|
||||
GDBStub::SetCpuStepFlag(false);
|
||||
}
|
||||
|
||||
HW::Update();
|
||||
Reschedule();
|
||||
|
||||
return status;
|
||||
@ -322,7 +320,10 @@ System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::st
|
||||
LOG_ERROR(Core, "Failed to find title id for ROM (Error {})",
|
||||
static_cast<u32>(load_result));
|
||||
}
|
||||
cheat_engine = std::make_unique<Cheats::CheatEngine>(title_id, *this);
|
||||
|
||||
cheat_engine.LoadCheatFile(title_id);
|
||||
cheat_engine.Connect();
|
||||
|
||||
perf_stats = std::make_unique<PerfStats>(title_id);
|
||||
|
||||
if (Settings::values.dump_textures) {
|
||||
@ -433,7 +434,7 @@ System::ResultStatus System::Init(Frontend::EmuWindow& emu_window,
|
||||
service_manager = std::make_unique<Service::SM::ServiceManager>(*this);
|
||||
archive_manager = std::make_unique<Service::FS::ArchiveManager>(*this);
|
||||
|
||||
HW::Init(*memory);
|
||||
HW::AES::InitKeys();
|
||||
Service::Init(*this);
|
||||
GDBStub::DeferStart();
|
||||
|
||||
@ -443,7 +444,16 @@ System::ResultStatus System::Init(Frontend::EmuWindow& emu_window,
|
||||
|
||||
custom_tex_manager = std::make_unique<VideoCore::CustomTexManager>(*this);
|
||||
|
||||
VideoCore::Init(emu_window, secondary_window, *this);
|
||||
auto gsp = service_manager->GetService<Service::GSP::GSP_GPU>("gsp::Gpu");
|
||||
gpu = std::make_unique<VideoCore::GPU>(*this, emu_window, secondary_window);
|
||||
gpu->SetInterruptHandler(
|
||||
[gsp](Service::GSP::InterruptId interrupt_id) { gsp->SignalInterrupt(interrupt_id); });
|
||||
|
||||
auto plg_ldr = Service::PLGLDR::GetService(*this);
|
||||
if (plg_ldr) {
|
||||
plg_ldr->SetEnabled(Settings::values.plugin_loader_enabled.GetValue());
|
||||
plg_ldr->SetAllowGameChangeState(Settings::values.allow_plugin_loader.GetValue());
|
||||
}
|
||||
|
||||
LOG_DEBUG(Core, "Initialized OK");
|
||||
|
||||
@ -452,8 +462,8 @@ System::ResultStatus System::Init(Frontend::EmuWindow& emu_window,
|
||||
return ResultStatus::Success;
|
||||
}
|
||||
|
||||
VideoCore::RendererBase& System::Renderer() {
|
||||
return *VideoCore::g_renderer;
|
||||
VideoCore::GPU& System::GPU() {
|
||||
return *gpu;
|
||||
}
|
||||
|
||||
Service::SM::ServiceManager& System::ServiceManager() {
|
||||
@ -501,11 +511,11 @@ const Memory::MemorySystem& System::Memory() const {
|
||||
}
|
||||
|
||||
Cheats::CheatEngine& System::CheatEngine() {
|
||||
return *cheat_engine;
|
||||
return cheat_engine;
|
||||
}
|
||||
|
||||
const Cheats::CheatEngine& System::CheatEngine() const {
|
||||
return *cheat_engine;
|
||||
return cheat_engine;
|
||||
}
|
||||
|
||||
void System::RegisterVideoDumper(std::shared_ptr<VideoDumper::Backend> dumper) {
|
||||
@ -555,12 +565,10 @@ void System::Shutdown(bool is_deserializing) {
|
||||
// Shutdown emulation session
|
||||
is_powered_on = false;
|
||||
|
||||
VideoCore::Shutdown();
|
||||
HW::Shutdown();
|
||||
gpu.reset();
|
||||
if (!is_deserializing) {
|
||||
GDBStub::Shutdown();
|
||||
perf_stats.reset();
|
||||
cheat_engine.reset();
|
||||
app_loader.reset();
|
||||
}
|
||||
custom_tex_manager.reset();
|
||||
@ -626,18 +634,9 @@ void System::ApplySettings() {
|
||||
GDBStub::SetServerPort(Settings::values.gdbstub_port.GetValue());
|
||||
GDBStub::ToggleServer(Settings::values.use_gdbstub.GetValue());
|
||||
|
||||
VideoCore::g_shader_jit_enabled = Settings::values.use_shader_jit.GetValue();
|
||||
VideoCore::g_hw_shader_enabled = Settings::values.use_hw_shader.GetValue();
|
||||
VideoCore::g_hw_shader_accurate_mul = Settings::values.shaders_accurate_mul.GetValue();
|
||||
|
||||
#ifndef ANDROID
|
||||
if (VideoCore::g_renderer) {
|
||||
VideoCore::g_renderer->UpdateCurrentFramebufferLayout();
|
||||
}
|
||||
#endif
|
||||
|
||||
if (VideoCore::g_renderer) {
|
||||
auto& settings = VideoCore::g_renderer->Settings();
|
||||
if (gpu) {
|
||||
gpu->Renderer().UpdateCurrentFramebufferLayout();
|
||||
auto& settings = gpu->Renderer().Settings();
|
||||
settings.bg_color_update_requested = true;
|
||||
settings.shader_update_requested = true;
|
||||
}
|
||||
@ -673,9 +672,11 @@ void System::ApplySettings() {
|
||||
Service::MIC::ReloadMic(*this);
|
||||
}
|
||||
|
||||
Service::PLGLDR::PLG_LDR::SetEnabled(Settings::values.plugin_loader_enabled.GetValue());
|
||||
Service::PLGLDR::PLG_LDR::SetAllowGameChangeState(
|
||||
Settings::values.allow_plugin_loader.GetValue());
|
||||
auto plg_ldr = Service::PLGLDR::GetService(*this);
|
||||
if (plg_ldr) {
|
||||
plg_ldr->SetEnabled(Settings::values.plugin_loader_enabled.GetValue());
|
||||
plg_ldr->SetAllowGameChangeState(Settings::values.allow_plugin_loader.GetValue());
|
||||
}
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
@ -699,17 +700,15 @@ void System::serialize(Archive& ar, const unsigned int file_version) {
|
||||
*m_emu_window, m_secondary_window, *memory_mode.first, *n3ds_hw_caps.first, num_cores);
|
||||
}
|
||||
|
||||
// flush on save, don't flush on load
|
||||
bool should_flush = !Archive::is_loading::value;
|
||||
Memory::RasterizerClearAll(should_flush);
|
||||
// Flush on save, don't flush on load
|
||||
const bool should_flush = !Archive::is_loading::value;
|
||||
gpu->ClearAll(should_flush);
|
||||
ar&* timing.get();
|
||||
for (u32 i = 0; i < num_cores; i++) {
|
||||
ar&* cpu_cores[i].get();
|
||||
}
|
||||
ar&* service_manager.get();
|
||||
ar&* archive_manager.get();
|
||||
ar& GPU::g_regs;
|
||||
ar& LCD::g_regs;
|
||||
|
||||
// NOTE: DSP doesn't like being destroyed and recreated. So instead we do an inline
|
||||
// serialization; this means that the DSP Settings need to match for loading to work.
|
||||
@ -722,16 +721,21 @@ void System::serialize(Archive& ar, const unsigned int file_version) {
|
||||
|
||||
ar&* memory.get();
|
||||
ar&* kernel.get();
|
||||
VideoCore::serialize(ar, file_version);
|
||||
ar&* gpu.get();
|
||||
ar& movie;
|
||||
|
||||
// This needs to be set from somewhere - might as well be here!
|
||||
if (Archive::is_loading::value) {
|
||||
timing->UnlockEventQueue();
|
||||
Service::GSP::SetGlobalModule(*this);
|
||||
memory->SetDSP(*dsp_core);
|
||||
cheat_engine->Connect();
|
||||
VideoCore::g_renderer->Sync();
|
||||
cheat_engine.Connect();
|
||||
gpu->Sync();
|
||||
|
||||
// Re-register gpu callback, because gsp service changed after service_manager got
|
||||
// serialized
|
||||
auto gsp = service_manager->GetService<Service::GSP::GSP_GPU>("gsp::Gpu");
|
||||
gpu->SetInterruptHandler(
|
||||
[gsp](Service::GSP::InterruptId interrupt_id) { gsp->SignalInterrupt(interrupt_id); });
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -11,6 +11,7 @@
|
||||
#include <boost/serialization/version.hpp>
|
||||
#include "common/common_types.h"
|
||||
#include "core/arm/arm_interface.h"
|
||||
#include "core/cheats/cheats.h"
|
||||
#include "core/movie.h"
|
||||
#include "core/perf_stats.h"
|
||||
|
||||
@ -48,19 +49,19 @@ struct New3dsHwCapabilities;
|
||||
enum class MemoryMode : u8;
|
||||
} // namespace Kernel
|
||||
|
||||
namespace Cheats {
|
||||
class CheatEngine;
|
||||
}
|
||||
|
||||
namespace VideoDumper {
|
||||
class Backend;
|
||||
}
|
||||
|
||||
namespace VideoCore {
|
||||
class CustomTexManager;
|
||||
class RendererBase;
|
||||
class GPU;
|
||||
} // namespace VideoCore
|
||||
|
||||
namespace Pica {
|
||||
class DebugContext;
|
||||
}
|
||||
|
||||
namespace Loader {
|
||||
class AppLoader;
|
||||
}
|
||||
@ -217,7 +218,7 @@ public:
|
||||
return *dsp_core;
|
||||
}
|
||||
|
||||
[[nodiscard]] VideoCore::RendererBase& Renderer();
|
||||
[[nodiscard]] VideoCore::GPU& GPU();
|
||||
|
||||
/**
|
||||
* Gets a reference to the service manager.
|
||||
@ -384,6 +385,8 @@ private:
|
||||
/// Telemetry session for this emulation session
|
||||
std::unique_ptr<Core::TelemetrySession> telemetry_session;
|
||||
|
||||
std::unique_ptr<VideoCore::GPU> gpu;
|
||||
|
||||
/// Service manager
|
||||
std::unique_ptr<Service::SM::ServiceManager> service_manager;
|
||||
|
||||
@ -395,7 +398,7 @@ private:
|
||||
Core::Movie movie;
|
||||
|
||||
/// Cheats manager
|
||||
std::unique_ptr<Cheats::CheatEngine> cheat_engine;
|
||||
Cheats::CheatEngine cheat_engine;
|
||||
|
||||
/// Video dumper backend
|
||||
std::shared_ptr<VideoDumper::Backend> video_dumper;
|
||||
|
@ -37,6 +37,10 @@
|
||||
constexpr u64 BASE_CLOCK_RATE_ARM11 = 268111856;
|
||||
constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE_ARM11;
|
||||
|
||||
/// Refresh rate defined by ratio of ARM11 frequency to ARM11 ticks per frame
|
||||
/// (268,111,856) / (4,481,136) = 59.83122493939037Hz
|
||||
constexpr double SCREEN_REFRESH_RATE = BASE_CLOCK_RATE_ARM11 / static_cast<double>(4481136ull);
|
||||
|
||||
constexpr s64 msToCycles(int ms) {
|
||||
// since ms is int there is no way to overflow
|
||||
return BASE_CLOCK_RATE_ARM11 * static_cast<s64>(ms) / 1000;
|
||||
|
@ -11,10 +11,10 @@
|
||||
#include "common/scope_exit.h"
|
||||
#include "common/settings.h"
|
||||
#include "common/string_util.h"
|
||||
#include "core/core_timing.h"
|
||||
#include "core/dumping/ffmpeg_backend.h"
|
||||
#include "core/hw/gpu.h"
|
||||
#include "video_core/gpu.h"
|
||||
#include "video_core/renderer_base.h"
|
||||
#include "video_core/video_core.h"
|
||||
|
||||
using namespace DynamicLibrary;
|
||||
|
||||
@ -381,7 +381,7 @@ bool FFmpegVideoStream::InitFilters() {
|
||||
}
|
||||
|
||||
// Configure buffer source
|
||||
static constexpr AVRational src_time_base{static_cast<int>(GPU::frame_ticks),
|
||||
static constexpr AVRational src_time_base{static_cast<int>(VideoCore::FRAME_TICKS),
|
||||
static_cast<int>(BASE_CLOCK_RATE_ARM11)};
|
||||
const std::string in_args =
|
||||
fmt::format("video_size={}x{}:pix_fmt={}:time_base={}/{}:pixel_aspect=1", layout.width,
|
||||
@ -732,7 +732,7 @@ void FFmpegMuxer::WriteTrailer() {
|
||||
FFmpeg::av_write_trailer(format_context.get());
|
||||
}
|
||||
|
||||
FFmpegBackend::FFmpegBackend() = default;
|
||||
FFmpegBackend::FFmpegBackend(VideoCore::RendererBase& renderer_) : renderer{renderer_} {}
|
||||
|
||||
FFmpegBackend::~FFmpegBackend() {
|
||||
ASSERT_MSG(!IsDumping(), "Dumping must be stopped first");
|
||||
@ -796,7 +796,7 @@ bool FFmpegBackend::StartDumping(const std::string& path, const Layout::Framebuf
|
||||
}
|
||||
});
|
||||
|
||||
VideoCore::g_renderer->PrepareVideoDumping();
|
||||
renderer.PrepareVideoDumping();
|
||||
is_dumping = true;
|
||||
|
||||
return true;
|
||||
@ -829,7 +829,7 @@ void FFmpegBackend::AddAudioSample(const std::array<s16, 2>& sample) {
|
||||
|
||||
void FFmpegBackend::StopDumping() {
|
||||
is_dumping = false;
|
||||
VideoCore::g_renderer->CleanupVideoDumping();
|
||||
renderer.CleanupVideoDumping();
|
||||
|
||||
// Flush the video processing queue
|
||||
AddVideoFrame(VideoFrame());
|
||||
|
@ -18,6 +18,10 @@
|
||||
#include "common/threadsafe_queue.h"
|
||||
#include "core/dumping/backend.h"
|
||||
|
||||
namespace VideoCore {
|
||||
class RendererBase;
|
||||
}
|
||||
|
||||
namespace VideoDumper {
|
||||
|
||||
using VariableAudioFrame = std::vector<s16>;
|
||||
@ -181,7 +185,7 @@ private:
|
||||
*/
|
||||
class FFmpegBackend : public Backend {
|
||||
public:
|
||||
FFmpegBackend();
|
||||
FFmpegBackend(VideoCore::RendererBase& renderer);
|
||||
~FFmpegBackend() override;
|
||||
bool StartDumping(const std::string& path, const Layout::FramebufferLayout& layout) override;
|
||||
void AddVideoFrame(VideoFrame frame) override;
|
||||
@ -194,6 +198,7 @@ public:
|
||||
private:
|
||||
void EndDumping();
|
||||
|
||||
VideoCore::RendererBase& renderer;
|
||||
std::atomic_bool is_dumping = false; ///< Whether the backend is currently dumping
|
||||
|
||||
FFmpegMuxer ffmpeg{};
|
||||
|
@ -127,7 +127,7 @@ public:
|
||||
* @param path Path relative to the archive
|
||||
* @return Result of the operation
|
||||
*/
|
||||
virtual ResultCode DeleteFile(const Path& path) const = 0;
|
||||
virtual Result DeleteFile(const Path& path) const = 0;
|
||||
|
||||
/**
|
||||
* Rename a File specified by its path
|
||||
@ -135,21 +135,21 @@ public:
|
||||
* @param dest_path Destination path relative to the archive
|
||||
* @return Result of the operation
|
||||
*/
|
||||
virtual ResultCode RenameFile(const Path& src_path, const Path& dest_path) const = 0;
|
||||
virtual Result RenameFile(const Path& src_path, const Path& dest_path) const = 0;
|
||||
|
||||
/**
|
||||
* Delete a directory specified by its path
|
||||
* @param path Path relative to the archive
|
||||
* @return Result of the operation
|
||||
*/
|
||||
virtual ResultCode DeleteDirectory(const Path& path) const = 0;
|
||||
virtual Result DeleteDirectory(const Path& path) const = 0;
|
||||
|
||||
/**
|
||||
* Delete a directory specified by its path and anything under it
|
||||
* @param path Path relative to the archive
|
||||
* @return Result of the operation
|
||||
*/
|
||||
virtual ResultCode DeleteDirectoryRecursively(const Path& path) const = 0;
|
||||
virtual Result DeleteDirectoryRecursively(const Path& path) const = 0;
|
||||
|
||||
/**
|
||||
* Create a file specified by its path
|
||||
@ -157,14 +157,14 @@ public:
|
||||
* @param size The size of the new file, filled with zeroes
|
||||
* @return Result of the operation
|
||||
*/
|
||||
virtual ResultCode CreateFile(const Path& path, u64 size) const = 0;
|
||||
virtual Result CreateFile(const Path& path, u64 size) const = 0;
|
||||
|
||||
/**
|
||||
* Create a directory specified by its path
|
||||
* @param path Path relative to the archive
|
||||
* @return Result of the operation
|
||||
*/
|
||||
virtual ResultCode CreateDirectory(const Path& path) const = 0;
|
||||
virtual Result CreateDirectory(const Path& path) const = 0;
|
||||
|
||||
/**
|
||||
* Rename a Directory specified by its path
|
||||
@ -172,7 +172,7 @@ public:
|
||||
* @param dest_path Destination path relative to the archive
|
||||
* @return Result of the operation
|
||||
*/
|
||||
virtual ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const = 0;
|
||||
virtual Result RenameDirectory(const Path& src_path, const Path& dest_path) const = 0;
|
||||
|
||||
/**
|
||||
* Open a directory specified by its path
|
||||
@ -229,10 +229,10 @@ public:
|
||||
* @param path Path to the archive
|
||||
* @param format_info Format information for the new archive
|
||||
* @param program_id the program ID of the client that requests the operation
|
||||
* @return ResultCode of the operation, 0 on success
|
||||
* @return Result of the operation, 0 on success
|
||||
*/
|
||||
virtual ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) = 0;
|
||||
virtual Result Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) = 0;
|
||||
|
||||
/**
|
||||
* Retrieves the format info about the archive with the specified path
|
||||
|
@ -40,7 +40,7 @@ public:
|
||||
ResultVal<std::size_t> Write(u64 offset, std::size_t length, bool flush,
|
||||
const u8* buffer) override {
|
||||
if (offset > size) {
|
||||
return ERR_WRITE_BEYOND_END;
|
||||
return ResultWriteBeyondEnd;
|
||||
} else if (offset == size) {
|
||||
return 0ULL;
|
||||
}
|
||||
@ -108,17 +108,17 @@ public:
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
if (mode.hex == 0) {
|
||||
LOG_ERROR(Service_FS, "Empty open mode");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
if (mode.create_flag) {
|
||||
LOG_ERROR(Service_FS, "Create flag is not supported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -126,17 +126,17 @@ public:
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_PATH_NOT_FOUND;
|
||||
return ResultPathNotFound;
|
||||
case PathParser::FileInPath:
|
||||
case PathParser::DirectoryFound:
|
||||
LOG_ERROR(Service_FS, "Unexpected file or directory in {}", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY;
|
||||
return ResultUnexpectedFileOrDirectory;
|
||||
case PathParser::NotFound:
|
||||
LOG_ERROR(Service_FS, "{} not found", full_path);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
case PathParser::FileFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
@ -144,7 +144,7 @@ public:
|
||||
FileUtil::IOFile file(full_path, "r+b");
|
||||
if (!file.IsOpen()) {
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Unknown error opening {}", full_path);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
}
|
||||
|
||||
Mode rwmode;
|
||||
@ -155,10 +155,10 @@ public:
|
||||
std::move(delay_generator));
|
||||
}
|
||||
|
||||
ResultCode CreateFile(const Path& path, u64 size) const override {
|
||||
Result CreateFile(const Path& path, u64 size) const override {
|
||||
if (size == 0) {
|
||||
LOG_ERROR(Service_FS, "Zero-size file is not supported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
return SaveDataArchive::CreateFile(path, size);
|
||||
}
|
||||
@ -250,18 +250,18 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_ExtSaveData::Open(cons
|
||||
// TODO(Subv): Verify the archive behavior of SharedExtSaveData compared to ExtSaveData.
|
||||
// ExtSaveData seems to return FS_NotFound (120) when the archive doesn't exist.
|
||||
if (type != ExtSaveDataType::Shared) {
|
||||
return ERR_NOT_FOUND_INVALID_STATE;
|
||||
return ResultNotFoundInvalidState;
|
||||
} else {
|
||||
return ERR_NOT_FORMATTED;
|
||||
return ResultNotFormatted;
|
||||
}
|
||||
}
|
||||
std::unique_ptr<DelayGenerator> delay_generator = std::make_unique<ExtSaveDataDelayGenerator>();
|
||||
return std::make_unique<ExtSaveDataArchive>(fullpath, std::move(delay_generator));
|
||||
}
|
||||
|
||||
ResultCode ArchiveFactory_ExtSaveData::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
Result ArchiveFactory_ExtSaveData::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
auto corrected_path = GetCorrectedPath(path);
|
||||
|
||||
// These folders are always created with the ExtSaveData
|
||||
@ -276,11 +276,11 @@ ResultCode ArchiveFactory_ExtSaveData::Format(const Path& path,
|
||||
|
||||
if (!file.IsOpen()) {
|
||||
// TODO(Subv): Find the correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
file.WriteBytes(&format_info, sizeof(format_info));
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
ResultVal<ArchiveFormatInfo> ArchiveFactory_ExtSaveData::GetFormatInfo(const Path& path,
|
||||
@ -291,7 +291,7 @@ ResultVal<ArchiveFormatInfo> ArchiveFactory_ExtSaveData::GetFormatInfo(const Pat
|
||||
if (!file.IsOpen()) {
|
||||
LOG_ERROR(Service_FS, "Could not open metadata information for archive");
|
||||
// TODO(Subv): Verify error code
|
||||
return ERR_NOT_FORMATTED;
|
||||
return ResultNotFormatted;
|
||||
}
|
||||
|
||||
ArchiveFormatInfo info = {};
|
||||
|
@ -31,8 +31,8 @@ public:
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path, u64 program_id) override;
|
||||
ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
Result Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path, u64 program_id) const override;
|
||||
|
||||
const std::string& GetMountPoint() const {
|
||||
|
@ -73,13 +73,13 @@ ResultVal<std::unique_ptr<FileBackend>> NCCHArchive::OpenFile(const Path& path,
|
||||
const Mode& mode) const {
|
||||
if (path.GetType() != LowPathType::Binary) {
|
||||
LOG_ERROR(Service_FS, "Path need to be Binary");
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
std::vector<u8> binary = path.AsBinary();
|
||||
if (binary.size() != sizeof(NCCHFilePath)) {
|
||||
LOG_ERROR(Service_FS, "Wrong path size {}", binary.size());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
NCCHFilePath openfile_path;
|
||||
@ -174,63 +174,63 @@ ResultVal<std::unique_ptr<FileBackend>> NCCHArchive::OpenFile(const Path& path,
|
||||
return std::make_unique<IVFCFileInMemory>(std::move(archive_data), romfs_offset,
|
||||
romfs_size, std::move(delay_generator));
|
||||
}
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
}
|
||||
|
||||
return file;
|
||||
}
|
||||
|
||||
ResultCode NCCHArchive::DeleteFile(const Path& path) const {
|
||||
Result NCCHArchive::DeleteFile(const Path& path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to delete a file from an NCCH archive ({}).", GetName());
|
||||
// TODO(Subv): Verify error code
|
||||
return ResultCode(ErrorDescription::NoData, ErrorModule::FS, ErrorSummary::Canceled,
|
||||
ErrorLevel::Status);
|
||||
return Result(ErrorDescription::NoData, ErrorModule::FS, ErrorSummary::Canceled,
|
||||
ErrorLevel::Status);
|
||||
}
|
||||
|
||||
ResultCode NCCHArchive::RenameFile(const Path& src_path, const Path& dest_path) const {
|
||||
Result NCCHArchive::RenameFile(const Path& src_path, const Path& dest_path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to rename a file within an NCCH archive ({}).", GetName());
|
||||
// TODO(wwylele): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultCode NCCHArchive::DeleteDirectory(const Path& path) const {
|
||||
Result NCCHArchive::DeleteDirectory(const Path& path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to delete a directory from an NCCH archive ({}).",
|
||||
GetName());
|
||||
// TODO(wwylele): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultCode NCCHArchive::DeleteDirectoryRecursively(const Path& path) const {
|
||||
Result NCCHArchive::DeleteDirectoryRecursively(const Path& path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to delete a directory from an NCCH archive ({}).",
|
||||
GetName());
|
||||
// TODO(wwylele): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultCode NCCHArchive::CreateFile(const Path& path, u64 size) const {
|
||||
Result NCCHArchive::CreateFile(const Path& path, u64 size) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to create a file in an NCCH archive ({}).", GetName());
|
||||
// TODO: Verify error code
|
||||
return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
|
||||
ErrorLevel::Permanent);
|
||||
return Result(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
|
||||
ErrorLevel::Permanent);
|
||||
}
|
||||
|
||||
ResultCode NCCHArchive::CreateDirectory(const Path& path) const {
|
||||
Result NCCHArchive::CreateDirectory(const Path& path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to create a directory in an NCCH archive ({}).", GetName());
|
||||
// TODO(wwylele): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultCode NCCHArchive::RenameDirectory(const Path& src_path, const Path& dest_path) const {
|
||||
Result NCCHArchive::RenameDirectory(const Path& src_path, const Path& dest_path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to rename a file within an NCCH archive ({}).", GetName());
|
||||
// TODO(wwylele): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<DirectoryBackend>> NCCHArchive::OpenDirectory(const Path& path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to open a directory within an NCCH archive ({}).",
|
||||
GetName().c_str());
|
||||
// TODO(shinyquagsire23): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
u64 NCCHArchive::GetFreeBytes() const {
|
||||
@ -276,13 +276,13 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_NCCH::Open(const Path&
|
||||
u64 program_id) {
|
||||
if (path.GetType() != LowPathType::Binary) {
|
||||
LOG_ERROR(Service_FS, "Path need to be Binary");
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
std::vector<u8> binary = path.AsBinary();
|
||||
if (binary.size() != sizeof(NCCHArchivePath)) {
|
||||
LOG_ERROR(Service_FS, "Wrong path size {}", binary.size());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
NCCHArchivePath open_path;
|
||||
@ -292,20 +292,19 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_NCCH::Open(const Path&
|
||||
open_path.tid, static_cast<Service::FS::MediaType>(open_path.media_type & 0xFF));
|
||||
}
|
||||
|
||||
ResultCode ArchiveFactory_NCCH::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
Result ArchiveFactory_NCCH::Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
LOG_ERROR(Service_FS, "Attempted to format a NCCH archive.");
|
||||
// TODO: Verify error code
|
||||
return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
|
||||
ErrorLevel::Permanent);
|
||||
return Result(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
|
||||
ErrorLevel::Permanent);
|
||||
}
|
||||
|
||||
ResultVal<ArchiveFormatInfo> ArchiveFactory_NCCH::GetFormatInfo(const Path& path,
|
||||
u64 program_id) const {
|
||||
// TODO(Subv): Implement
|
||||
LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
} // namespace FileSys
|
||||
|
@ -50,13 +50,13 @@ public:
|
||||
|
||||
ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path,
|
||||
const Mode& mode) const override;
|
||||
ResultCode DeleteFile(const Path& path) const override;
|
||||
ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
|
||||
ResultCode DeleteDirectory(const Path& path) const override;
|
||||
ResultCode DeleteDirectoryRecursively(const Path& path) const override;
|
||||
ResultCode CreateFile(const Path& path, u64 size) const override;
|
||||
ResultCode CreateDirectory(const Path& path) const override;
|
||||
ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
|
||||
Result DeleteFile(const Path& path) const override;
|
||||
Result RenameFile(const Path& src_path, const Path& dest_path) const override;
|
||||
Result DeleteDirectory(const Path& path) const override;
|
||||
Result DeleteDirectoryRecursively(const Path& path) const override;
|
||||
Result CreateFile(const Path& path, u64 size) const override;
|
||||
Result CreateDirectory(const Path& path) const override;
|
||||
Result RenameDirectory(const Path& src_path, const Path& dest_path) const override;
|
||||
ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override;
|
||||
u64 GetFreeBytes() const override;
|
||||
|
||||
@ -114,8 +114,8 @@ public:
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path, u64 program_id) override;
|
||||
ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
Result Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path, u64 program_id) const override;
|
||||
|
||||
private:
|
||||
|
@ -25,14 +25,14 @@ template <typename T>
|
||||
ResultVal<std::tuple<MediaType, u64>> ParsePath(const Path& path, T program_id_reader) {
|
||||
if (path.GetType() != LowPathType::Binary) {
|
||||
LOG_ERROR(Service_FS, "Wrong path type {}", path.GetType());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
std::vector<u8> vec_data = path.AsBinary();
|
||||
|
||||
if (vec_data.size() != 12) {
|
||||
LOG_ERROR(Service_FS, "Wrong path length {}", vec_data.size());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const u32* data = reinterpret_cast<const u32*>(vec_data.data());
|
||||
@ -42,7 +42,7 @@ ResultVal<std::tuple<MediaType, u64>> ParsePath(const Path& path, T program_id_r
|
||||
LOG_ERROR(Service_FS, "Unsupported media type {}", media_type);
|
||||
|
||||
// Note: this is strange, but the error code was verified with a real 3DS
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
return std::make_tuple(media_type, program_id_reader(data));
|
||||
@ -72,16 +72,17 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_OtherSaveDataPermitted
|
||||
|
||||
if (media_type == MediaType::GameCard) {
|
||||
LOG_WARNING(Service_FS, "(stubbed) Unimplemented media type GameCard");
|
||||
return ERROR_GAMECARD_NOT_INSERTED;
|
||||
return ResultGamecardNotInserted;
|
||||
}
|
||||
|
||||
return sd_savedata_source->Open(program_id);
|
||||
}
|
||||
|
||||
ResultCode ArchiveFactory_OtherSaveDataPermitted::Format(
|
||||
const Path& path, const FileSys::ArchiveFormatInfo& format_info, u64 program_id) {
|
||||
Result ArchiveFactory_OtherSaveDataPermitted::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
LOG_ERROR(Service_FS, "Attempted to format a OtherSaveDataPermitted archive.");
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
ResultVal<ArchiveFormatInfo> ArchiveFactory_OtherSaveDataPermitted::GetFormatInfo(
|
||||
@ -92,7 +93,7 @@ ResultVal<ArchiveFormatInfo> ArchiveFactory_OtherSaveDataPermitted::GetFormatInf
|
||||
|
||||
if (media_type == MediaType::GameCard) {
|
||||
LOG_WARNING(Service_FS, "(stubbed) Unimplemented media type GameCard");
|
||||
return ERROR_GAMECARD_NOT_INSERTED;
|
||||
return ResultGamecardNotInserted;
|
||||
}
|
||||
|
||||
return sd_savedata_source->GetFormatInfo(program_id);
|
||||
@ -110,21 +111,22 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_OtherSaveDataGeneral::
|
||||
|
||||
if (media_type == MediaType::GameCard) {
|
||||
LOG_WARNING(Service_FS, "(stubbed) Unimplemented media type GameCard");
|
||||
return ERROR_GAMECARD_NOT_INSERTED;
|
||||
return ResultGamecardNotInserted;
|
||||
}
|
||||
|
||||
return sd_savedata_source->Open(program_id);
|
||||
}
|
||||
|
||||
ResultCode ArchiveFactory_OtherSaveDataGeneral::Format(
|
||||
const Path& path, const FileSys::ArchiveFormatInfo& format_info, u64 /*client_program_id*/) {
|
||||
Result ArchiveFactory_OtherSaveDataGeneral::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 /*client_program_id*/) {
|
||||
MediaType media_type;
|
||||
u64 program_id;
|
||||
CASCADE_RESULT(std::tie(media_type, program_id), ParsePathGeneral(path));
|
||||
|
||||
if (media_type == MediaType::GameCard) {
|
||||
LOG_WARNING(Service_FS, "(stubbed) Unimplemented media type GameCard");
|
||||
return ERROR_GAMECARD_NOT_INSERTED;
|
||||
return ResultGamecardNotInserted;
|
||||
}
|
||||
|
||||
return sd_savedata_source->Format(program_id, format_info);
|
||||
@ -138,7 +140,7 @@ ResultVal<ArchiveFormatInfo> ArchiveFactory_OtherSaveDataGeneral::GetFormatInfo(
|
||||
|
||||
if (media_type == MediaType::GameCard) {
|
||||
LOG_WARNING(Service_FS, "(stubbed) Unimplemented media type GameCard");
|
||||
return ERROR_GAMECARD_NOT_INSERTED;
|
||||
return ResultGamecardNotInserted;
|
||||
}
|
||||
|
||||
return sd_savedata_source->GetFormatInfo(program_id);
|
||||
|
@ -22,8 +22,8 @@ public:
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path, u64 program_id) override;
|
||||
ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
Result Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path, u64 program_id) const override;
|
||||
|
||||
private:
|
||||
@ -49,8 +49,8 @@ public:
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path, u64 program_id) override;
|
||||
ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
Result Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path, u64 program_id) const override;
|
||||
|
||||
private:
|
||||
|
@ -21,9 +21,9 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SaveData::Open(const P
|
||||
return sd_savedata_source->Open(program_id);
|
||||
}
|
||||
|
||||
ResultCode ArchiveFactory_SaveData::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
Result ArchiveFactory_SaveData::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
return sd_savedata_source->Format(program_id, format_info);
|
||||
}
|
||||
|
||||
|
@ -20,8 +20,8 @@ public:
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path, u64 program_id) override;
|
||||
ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
Result Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
|
||||
ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path, u64 program_id) const override;
|
||||
|
||||
|
@ -62,17 +62,17 @@ ResultVal<std::unique_ptr<FileBackend>> SDMCArchive::OpenFileBase(const Path& pa
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
if (mode.hex == 0) {
|
||||
LOG_ERROR(Service_FS, "Empty open mode");
|
||||
return ERROR_INVALID_OPEN_FLAGS;
|
||||
return ResultInvalidOpenFlags;
|
||||
}
|
||||
|
||||
if (mode.create_flag && !mode.write_flag) {
|
||||
LOG_ERROR(Service_FS, "Create flag set but write flag not set");
|
||||
return ERROR_INVALID_OPEN_FLAGS;
|
||||
return ResultInvalidOpenFlags;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -80,19 +80,19 @@ ResultVal<std::unique_ptr<FileBackend>> SDMCArchive::OpenFileBase(const Path& pa
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
case PathParser::FileInPath:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::DirectoryFound:
|
||||
LOG_ERROR(Service_FS, "{} is not a file", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY_SDMC;
|
||||
return ResultUnexpectedFileOrDirectorySdmc;
|
||||
case PathParser::NotFound:
|
||||
if (!mode.create_flag) {
|
||||
LOG_ERROR(Service_FS, "Non-existing file {} can't be open without mode create.",
|
||||
full_path);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
} else {
|
||||
// Create the file
|
||||
FileUtil::CreateEmptyFile(full_path);
|
||||
@ -105,19 +105,19 @@ ResultVal<std::unique_ptr<FileBackend>> SDMCArchive::OpenFileBase(const Path& pa
|
||||
FileUtil::IOFile file(full_path, mode.write_flag ? "r+b" : "rb");
|
||||
if (!file.IsOpen()) {
|
||||
LOG_CRITICAL(Service_FS, "Error opening {}: {}", full_path, Common::GetLastErrorMsg());
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
}
|
||||
|
||||
std::unique_ptr<DelayGenerator> delay_generator = std::make_unique<SDMCDelayGenerator>();
|
||||
return std::make_unique<DiskFile>(std::move(file), mode, std::move(delay_generator));
|
||||
}
|
||||
|
||||
ResultCode SDMCArchive::DeleteFile(const Path& path) const {
|
||||
Result SDMCArchive::DeleteFile(const Path& path) const {
|
||||
const PathParser path_parser(path);
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -125,110 +125,109 @@ ResultCode SDMCArchive::DeleteFile(const Path& path) const {
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
case PathParser::FileInPath:
|
||||
case PathParser::NotFound:
|
||||
LOG_DEBUG(Service_FS, "{} not found", full_path);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::DirectoryFound:
|
||||
LOG_ERROR(Service_FS, "{} is not a file", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY_SDMC;
|
||||
return ResultUnexpectedFileOrDirectorySdmc;
|
||||
case PathParser::FileFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
|
||||
if (FileUtil::Delete(full_path)) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Unknown error deleting {}", full_path);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
}
|
||||
|
||||
ResultCode SDMCArchive::RenameFile(const Path& src_path, const Path& dest_path) const {
|
||||
Result SDMCArchive::RenameFile(const Path& src_path, const Path& dest_path) const {
|
||||
const PathParser path_parser_src(src_path);
|
||||
|
||||
// TODO: Verify these return codes with HW
|
||||
if (!path_parser_src.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid src path {}", src_path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const PathParser path_parser_dest(dest_path);
|
||||
|
||||
if (!path_parser_dest.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid dest path {}", dest_path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto src_path_full = path_parser_src.BuildHostPath(mount_point);
|
||||
const auto dest_path_full = path_parser_dest.BuildHostPath(mount_point);
|
||||
|
||||
if (FileUtil::Rename(src_path_full, dest_path_full)) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
// TODO(yuriks): This code probably isn't right, it'll return a Status even if the file didn't
|
||||
// exist or similar. Verify.
|
||||
return ResultCode(ErrorDescription::NoData, ErrorModule::FS, // TODO: verify description
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
return Result(ErrorDescription::NoData, ErrorModule::FS, // TODO: verify description
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
static ResultCode DeleteDirectoryHelper(const Path& path, const std::string& mount_point,
|
||||
T deleter) {
|
||||
static Result DeleteDirectoryHelper(const Path& path, const std::string& mount_point, T deleter) {
|
||||
const PathParser path_parser(path);
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
if (path_parser.IsRootDirectory())
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
case PathParser::NotFound:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::FileInPath:
|
||||
case PathParser::FileFound:
|
||||
LOG_ERROR(Service_FS, "Unexpected file in path {}", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY_SDMC;
|
||||
return ResultUnexpectedFileOrDirectorySdmc;
|
||||
case PathParser::DirectoryFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
|
||||
if (deleter(full_path)) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
LOG_ERROR(Service_FS, "Directory not empty {}", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY_SDMC;
|
||||
return ResultUnexpectedFileOrDirectorySdmc;
|
||||
}
|
||||
|
||||
ResultCode SDMCArchive::DeleteDirectory(const Path& path) const {
|
||||
Result SDMCArchive::DeleteDirectory(const Path& path) const {
|
||||
return DeleteDirectoryHelper(path, mount_point, FileUtil::DeleteDir);
|
||||
}
|
||||
|
||||
ResultCode SDMCArchive::DeleteDirectoryRecursively(const Path& path) const {
|
||||
Result SDMCArchive::DeleteDirectoryRecursively(const Path& path) const {
|
||||
return DeleteDirectoryHelper(
|
||||
path, mount_point, [](const std::string& p) { return FileUtil::DeleteDirRecursively(p); });
|
||||
}
|
||||
|
||||
ResultCode SDMCArchive::CreateFile(const FileSys::Path& path, u64 size) const {
|
||||
Result SDMCArchive::CreateFile(const FileSys::Path& path, u64 size) const {
|
||||
const PathParser path_parser(path);
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -236,44 +235,44 @@ ResultCode SDMCArchive::CreateFile(const FileSys::Path& path, u64 size) const {
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
case PathParser::FileInPath:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::DirectoryFound:
|
||||
LOG_ERROR(Service_FS, "{} already exists", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY_SDMC;
|
||||
return ResultUnexpectedFileOrDirectorySdmc;
|
||||
case PathParser::FileFound:
|
||||
LOG_ERROR(Service_FS, "{} already exists", full_path);
|
||||
return ERROR_ALREADY_EXISTS;
|
||||
return ResultAlreadyExists;
|
||||
case PathParser::NotFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
|
||||
if (size == 0) {
|
||||
FileUtil::CreateEmptyFile(full_path);
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
FileUtil::IOFile file(full_path, "wb");
|
||||
// Creates a sparse file (or a normal file on filesystems without the concept of sparse files)
|
||||
// We do this by seeking to the right size, then writing a single null byte.
|
||||
if (file.Seek(size - 1, SEEK_SET) && file.WriteBytes("", 1) == 1) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
LOG_ERROR(Service_FS, "Too large file");
|
||||
return ResultCode(ErrorDescription::TooLarge, ErrorModule::FS, ErrorSummary::OutOfResource,
|
||||
ErrorLevel::Info);
|
||||
return Result(ErrorDescription::TooLarge, ErrorModule::FS, ErrorSummary::OutOfResource,
|
||||
ErrorLevel::Info);
|
||||
}
|
||||
|
||||
ResultCode SDMCArchive::CreateDirectory(const Path& path) const {
|
||||
Result SDMCArchive::CreateDirectory(const Path& path) const {
|
||||
const PathParser path_parser(path);
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -281,55 +280,55 @@ ResultCode SDMCArchive::CreateDirectory(const Path& path) const {
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
case PathParser::FileInPath:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::DirectoryFound:
|
||||
case PathParser::FileFound:
|
||||
LOG_DEBUG(Service_FS, "{} already exists", full_path);
|
||||
return ERROR_ALREADY_EXISTS;
|
||||
return ResultAlreadyExists;
|
||||
case PathParser::NotFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
|
||||
if (FileUtil::CreateDir(mount_point + path.AsString())) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Unknown error creating {}", mount_point);
|
||||
return ResultCode(ErrorDescription::NoData, ErrorModule::FS, ErrorSummary::Canceled,
|
||||
ErrorLevel::Status);
|
||||
return Result(ErrorDescription::NoData, ErrorModule::FS, ErrorSummary::Canceled,
|
||||
ErrorLevel::Status);
|
||||
}
|
||||
|
||||
ResultCode SDMCArchive::RenameDirectory(const Path& src_path, const Path& dest_path) const {
|
||||
Result SDMCArchive::RenameDirectory(const Path& src_path, const Path& dest_path) const {
|
||||
const PathParser path_parser_src(src_path);
|
||||
|
||||
// TODO: Verify these return codes with HW
|
||||
if (!path_parser_src.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid src path {}", src_path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const PathParser path_parser_dest(dest_path);
|
||||
|
||||
if (!path_parser_dest.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid dest path {}", dest_path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto src_path_full = path_parser_src.BuildHostPath(mount_point);
|
||||
const auto dest_path_full = path_parser_dest.BuildHostPath(mount_point);
|
||||
|
||||
if (FileUtil::Rename(src_path_full, dest_path_full)) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
// TODO(yuriks): This code probably isn't right, it'll return a Status even if the file didn't
|
||||
// exist or similar. Verify.
|
||||
return ResultCode(ErrorDescription::NoData, ErrorModule::FS, // TODO: verify description
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
return Result(ErrorDescription::NoData, ErrorModule::FS, // TODO: verify description
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<DirectoryBackend>> SDMCArchive::OpenDirectory(const Path& path) const {
|
||||
@ -337,7 +336,7 @@ ResultVal<std::unique_ptr<DirectoryBackend>> SDMCArchive::OpenDirectory(const Pa
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -345,15 +344,15 @@ ResultVal<std::unique_ptr<DirectoryBackend>> SDMCArchive::OpenDirectory(const Pa
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
case PathParser::NotFound:
|
||||
case PathParser::FileFound:
|
||||
LOG_ERROR(Service_FS, "{} not found", full_path);
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
case PathParser::FileInPath:
|
||||
LOG_ERROR(Service_FS, "Unexpected file in path {}", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY_SDMC;
|
||||
return ResultUnexpectedFileOrDirectorySdmc;
|
||||
case PathParser::DirectoryFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
@ -392,18 +391,17 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SDMC::Open(const Path&
|
||||
return std::make_unique<SDMCArchive>(sdmc_directory, std::move(delay_generator));
|
||||
}
|
||||
|
||||
ResultCode ArchiveFactory_SDMC::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
Result ArchiveFactory_SDMC::Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
// This is kind of an undesirable operation, so let's just ignore it. :)
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
ResultVal<ArchiveFormatInfo> ArchiveFactory_SDMC::GetFormatInfo(const Path& path,
|
||||
u64 program_id) const {
|
||||
// TODO(Subv): Implement
|
||||
LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
} // namespace FileSys
|
||||
|
||||
|
@ -29,13 +29,13 @@ public:
|
||||
|
||||
ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path,
|
||||
const Mode& mode) const override;
|
||||
ResultCode DeleteFile(const Path& path) const override;
|
||||
ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
|
||||
ResultCode DeleteDirectory(const Path& path) const override;
|
||||
ResultCode DeleteDirectoryRecursively(const Path& path) const override;
|
||||
ResultCode CreateFile(const Path& path, u64 size) const override;
|
||||
ResultCode CreateDirectory(const Path& path) const override;
|
||||
ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
|
||||
Result DeleteFile(const Path& path) const override;
|
||||
Result RenameFile(const Path& src_path, const Path& dest_path) const override;
|
||||
Result DeleteDirectory(const Path& path) const override;
|
||||
Result DeleteDirectoryRecursively(const Path& path) const override;
|
||||
Result CreateFile(const Path& path, u64 size) const override;
|
||||
Result CreateDirectory(const Path& path) const override;
|
||||
Result RenameDirectory(const Path& src_path, const Path& dest_path) const override;
|
||||
ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override;
|
||||
u64 GetFreeBytes() const override;
|
||||
|
||||
@ -68,8 +68,8 @@ public:
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path, u64 program_id) override;
|
||||
ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
Result Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path, u64 program_id) const override;
|
||||
|
||||
private:
|
||||
|
@ -44,7 +44,7 @@ ResultVal<std::unique_ptr<FileBackend>> SDMCWriteOnlyArchive::OpenFile(const Pat
|
||||
const Mode& mode) const {
|
||||
if (mode.read_flag) {
|
||||
LOG_ERROR(Service_FS, "Read flag is not supported");
|
||||
return ERROR_INVALID_READ_FLAG;
|
||||
return ResultInvalidReadFlag;
|
||||
}
|
||||
return SDMCArchive::OpenFileBase(path, mode);
|
||||
}
|
||||
@ -52,7 +52,7 @@ ResultVal<std::unique_ptr<FileBackend>> SDMCWriteOnlyArchive::OpenFile(const Pat
|
||||
ResultVal<std::unique_ptr<DirectoryBackend>> SDMCWriteOnlyArchive::OpenDirectory(
|
||||
const Path& path) const {
|
||||
LOG_ERROR(Service_FS, "Not supported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
ArchiveFactory_SDMCWriteOnly::ArchiveFactory_SDMCWriteOnly(const std::string& mount_point)
|
||||
@ -81,19 +81,19 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SDMCWriteOnly::Open(co
|
||||
return std::make_unique<SDMCWriteOnlyArchive>(sdmc_directory, std::move(delay_generator));
|
||||
}
|
||||
|
||||
ResultCode ArchiveFactory_SDMCWriteOnly::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
Result ArchiveFactory_SDMCWriteOnly::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
// TODO(wwylele): hwtest this
|
||||
LOG_ERROR(Service_FS, "Attempted to format a SDMC write-only archive.");
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultVal<ArchiveFormatInfo> ArchiveFactory_SDMCWriteOnly::GetFormatInfo(const Path& path,
|
||||
u64 program_id) const {
|
||||
// TODO(Subv): Implement
|
||||
LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
} // namespace FileSys
|
||||
|
@ -54,8 +54,8 @@ public:
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path, u64 program_id) override;
|
||||
ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
Result Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path, u64 program_id) const override;
|
||||
|
||||
private:
|
||||
|
@ -39,12 +39,12 @@ public:
|
||||
ResultVal<std::size_t> Read(u64 offset, std::size_t length, u8* buffer) const override {
|
||||
if (offset != 0) {
|
||||
LOG_ERROR(Service_FS, "offset must be zero!");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
if (length != data->size()) {
|
||||
LOG_ERROR(Service_FS, "size must match the file size!");
|
||||
return ERROR_INCORRECT_EXEFS_READ_SIZE;
|
||||
return ResultIncorrectExefsReadSize;
|
||||
}
|
||||
|
||||
std::memcpy(buffer, data->data(), data->size());
|
||||
@ -54,7 +54,7 @@ public:
|
||||
ResultVal<std::size_t> Write(u64 offset, std::size_t length, bool flush,
|
||||
const u8* buffer) override {
|
||||
LOG_ERROR(Service_FS, "The file is read-only!");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
u64 GetSize() const override {
|
||||
@ -99,13 +99,13 @@ public:
|
||||
|
||||
if (path.GetType() != LowPathType::Binary) {
|
||||
LOG_ERROR(Service_FS, "Path need to be Binary");
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
std::vector<u8> binary = path.AsBinary();
|
||||
if (binary.size() != sizeof(SelfNCCHFilePath)) {
|
||||
LOG_ERROR(Service_FS, "Wrong path size {}", binary.size());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
SelfNCCHFilePath file_path;
|
||||
@ -120,7 +120,7 @@ public:
|
||||
|
||||
case SelfNCCHFilePathType::Code:
|
||||
LOG_ERROR(Service_FS, "Reading the code section is not supported!");
|
||||
return ERROR_COMMAND_NOT_ALLOWED;
|
||||
return ResultCommandNotAllowed;
|
||||
|
||||
case SelfNCCHFilePathType::ExeFS: {
|
||||
const auto& raw = file_path.exefs_filename;
|
||||
@ -130,48 +130,48 @@ public:
|
||||
}
|
||||
default:
|
||||
LOG_ERROR(Service_FS, "Unknown file type {}!", file_path.type);
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
}
|
||||
|
||||
ResultCode DeleteFile(const Path& path) const override {
|
||||
Result DeleteFile(const Path& path) const override {
|
||||
LOG_ERROR(Service_FS, "Unsupported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override {
|
||||
Result RenameFile(const Path& src_path, const Path& dest_path) const override {
|
||||
LOG_ERROR(Service_FS, "Unsupported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
ResultCode DeleteDirectory(const Path& path) const override {
|
||||
Result DeleteDirectory(const Path& path) const override {
|
||||
LOG_ERROR(Service_FS, "Unsupported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
ResultCode DeleteDirectoryRecursively(const Path& path) const override {
|
||||
Result DeleteDirectoryRecursively(const Path& path) const override {
|
||||
LOG_ERROR(Service_FS, "Unsupported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
ResultCode CreateFile(const Path& path, u64 size) const override {
|
||||
Result CreateFile(const Path& path, u64 size) const override {
|
||||
LOG_ERROR(Service_FS, "Unsupported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
ResultCode CreateDirectory(const Path& path) const override {
|
||||
Result CreateDirectory(const Path& path) const override {
|
||||
LOG_ERROR(Service_FS, "Unsupported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override {
|
||||
Result RenameDirectory(const Path& src_path, const Path& dest_path) const override {
|
||||
LOG_ERROR(Service_FS, "Unsupported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override {
|
||||
LOG_ERROR(Service_FS, "Unsupported");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
u64 GetFreeBytes() const override {
|
||||
@ -186,7 +186,7 @@ private:
|
||||
return std::make_unique<IVFCFile>(ncch_data.romfs_file, std::move(delay_generator));
|
||||
} else {
|
||||
LOG_INFO(Service_FS, "Unable to read RomFS");
|
||||
return ERROR_ROMFS_NOT_FOUND;
|
||||
return ResultRomfsNotFound;
|
||||
}
|
||||
}
|
||||
|
||||
@ -198,7 +198,7 @@ private:
|
||||
std::move(delay_generator));
|
||||
} else {
|
||||
LOG_INFO(Service_FS, "Unable to read update RomFS");
|
||||
return ERROR_ROMFS_NOT_FOUND;
|
||||
return ResultRomfsNotFound;
|
||||
}
|
||||
}
|
||||
|
||||
@ -209,7 +209,7 @@ private:
|
||||
}
|
||||
|
||||
LOG_WARNING(Service_FS, "Unable to read icon");
|
||||
return ERROR_EXEFS_SECTION_NOT_FOUND;
|
||||
return ResultExefsSectionNotFound;
|
||||
}
|
||||
|
||||
if (filename == "logo") {
|
||||
@ -218,7 +218,7 @@ private:
|
||||
}
|
||||
|
||||
LOG_WARNING(Service_FS, "Unable to read logo");
|
||||
return ERROR_EXEFS_SECTION_NOT_FOUND;
|
||||
return ResultExefsSectionNotFound;
|
||||
}
|
||||
|
||||
if (filename == "banner") {
|
||||
@ -227,11 +227,11 @@ private:
|
||||
}
|
||||
|
||||
LOG_WARNING(Service_FS, "Unable to read banner");
|
||||
return ERROR_EXEFS_SECTION_NOT_FOUND;
|
||||
return ResultExefsSectionNotFound;
|
||||
}
|
||||
|
||||
LOG_ERROR(Service_FS, "Unknown ExeFS section {}!", filename);
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
NCCHData ncch_data;
|
||||
@ -296,16 +296,16 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SelfNCCH::Open(const P
|
||||
return std::make_unique<SelfNCCHArchive>(ncch_data[program_id]);
|
||||
}
|
||||
|
||||
ResultCode ArchiveFactory_SelfNCCH::Format(const Path&, const FileSys::ArchiveFormatInfo&,
|
||||
u64 program_id) {
|
||||
Result ArchiveFactory_SelfNCCH::Format(const Path&, const FileSys::ArchiveFormatInfo&,
|
||||
u64 program_id) {
|
||||
LOG_ERROR(Service_FS, "Attempted to format a SelfNCCH archive.");
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
ResultVal<ArchiveFormatInfo> ArchiveFactory_SelfNCCH::GetFormatInfo(const Path&,
|
||||
u64 program_id) const {
|
||||
LOG_ERROR(Service_FS, "Attempted to get format info of a SelfNCCH archive");
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
} // namespace FileSys
|
||||
|
@ -50,8 +50,8 @@ public:
|
||||
return "SelfNCCH";
|
||||
}
|
||||
ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path, u64 program_id) override;
|
||||
ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
Result Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path, u64 program_id) const override;
|
||||
|
||||
private:
|
||||
|
@ -47,14 +47,14 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveSource_SDSaveData::Open(u64 pr
|
||||
// save file/directory structure expected by the game has not yet been initialized.
|
||||
// Returning the NotFormatted error code will signal the game to provision the SaveData
|
||||
// archive with the files and folders that it expects.
|
||||
return ERR_NOT_FORMATTED;
|
||||
return ResultNotFormatted;
|
||||
}
|
||||
|
||||
return std::make_unique<SaveDataArchive>(std::move(concrete_mount_point));
|
||||
}
|
||||
|
||||
ResultCode ArchiveSource_SDSaveData::Format(u64 program_id,
|
||||
const FileSys::ArchiveFormatInfo& format_info) {
|
||||
Result ArchiveSource_SDSaveData::Format(u64 program_id,
|
||||
const FileSys::ArchiveFormatInfo& format_info) {
|
||||
std::string concrete_mount_point = GetSaveDataPath(mount_point, program_id);
|
||||
FileUtil::DeleteDirRecursively(concrete_mount_point);
|
||||
FileUtil::CreateFullPath(concrete_mount_point);
|
||||
@ -65,9 +65,9 @@ ResultCode ArchiveSource_SDSaveData::Format(u64 program_id,
|
||||
|
||||
if (file.IsOpen()) {
|
||||
file.WriteBytes(&format_info, sizeof(format_info));
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
ResultVal<ArchiveFormatInfo> ArchiveSource_SDSaveData::GetFormatInfo(u64 program_id) const {
|
||||
@ -77,7 +77,7 @@ ResultVal<ArchiveFormatInfo> ArchiveSource_SDSaveData::GetFormatInfo(u64 program
|
||||
if (!file.IsOpen()) {
|
||||
LOG_ERROR(Service_FS, "Could not open metadata information for archive");
|
||||
// TODO(Subv): Verify error code
|
||||
return ERR_NOT_FORMATTED;
|
||||
return ResultNotFormatted;
|
||||
}
|
||||
|
||||
ArchiveFormatInfo info = {};
|
||||
|
@ -19,7 +19,7 @@ public:
|
||||
explicit ArchiveSource_SDSaveData(const std::string& mount_point);
|
||||
|
||||
ResultVal<std::unique_ptr<ArchiveBackend>> Open(u64 program_id);
|
||||
ResultCode Format(u64 program_id, const FileSys::ArchiveFormatInfo& format_info);
|
||||
Result Format(u64 program_id, const FileSys::ArchiveFormatInfo& format_info);
|
||||
ResultVal<ArchiveFormatInfo> GetFormatInfo(u64 program_id) const;
|
||||
|
||||
static std::string GetSaveDataPathFor(const std::string& mount_point, u64 program_id);
|
||||
|
@ -57,25 +57,25 @@ ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SystemSaveData::Open(c
|
||||
std::string fullpath = GetSystemSaveDataPath(base_path, path);
|
||||
if (!FileUtil::Exists(fullpath)) {
|
||||
// TODO(Subv): Check error code, this one is probably wrong
|
||||
return ERROR_NOT_FOUND;
|
||||
return ResultNotFound;
|
||||
}
|
||||
return std::make_unique<SaveDataArchive>(fullpath);
|
||||
}
|
||||
|
||||
ResultCode ArchiveFactory_SystemSaveData::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
Result ArchiveFactory_SystemSaveData::Format(const Path& path,
|
||||
const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) {
|
||||
std::string fullpath = GetSystemSaveDataPath(base_path, path);
|
||||
FileUtil::DeleteDirRecursively(fullpath);
|
||||
FileUtil::CreateFullPath(fullpath);
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
ResultVal<ArchiveFormatInfo> ArchiveFactory_SystemSaveData::GetFormatInfo(const Path& path,
|
||||
u64 program_id) const {
|
||||
// TODO(Subv): Implement
|
||||
LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
} // namespace FileSys
|
||||
|
@ -20,8 +20,8 @@ public:
|
||||
explicit ArchiveFactory_SystemSaveData(const std::string& mount_point);
|
||||
|
||||
ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path, u64 program_id) override;
|
||||
ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
Result Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
||||
u64 program_id) override;
|
||||
ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path, u64 program_id) const override;
|
||||
|
||||
std::string GetName() const override {
|
||||
|
@ -19,7 +19,7 @@ namespace FileSys {
|
||||
ResultVal<std::size_t> DiskFile::Read(const u64 offset, const std::size_t length,
|
||||
u8* buffer) const {
|
||||
if (!mode.read_flag)
|
||||
return ERROR_INVALID_OPEN_FLAGS;
|
||||
return ResultInvalidOpenFlags;
|
||||
|
||||
file->Seek(offset, SEEK_SET);
|
||||
return file->ReadBytes(buffer, length);
|
||||
@ -28,7 +28,7 @@ ResultVal<std::size_t> DiskFile::Read(const u64 offset, const std::size_t length
|
||||
ResultVal<std::size_t> DiskFile::Write(const u64 offset, const std::size_t length, const bool flush,
|
||||
const u8* buffer) {
|
||||
if (!mode.write_flag)
|
||||
return ERROR_INVALID_OPEN_FLAGS;
|
||||
return ResultInvalidOpenFlags;
|
||||
|
||||
file->Seek(offset, SEEK_SET);
|
||||
std::size_t written = file->WriteBytes(buffer, length);
|
||||
|
@ -35,63 +35,60 @@ enum {
|
||||
};
|
||||
}
|
||||
|
||||
constexpr ResultCode ERROR_INVALID_PATH(ErrCodes::InvalidPath, ErrorModule::FS,
|
||||
ErrorSummary::InvalidArgument, ErrorLevel::Usage);
|
||||
constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(ErrCodes::UnsupportedOpenFlags, ErrorModule::FS,
|
||||
ErrorSummary::NotSupported, ErrorLevel::Usage);
|
||||
constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(ErrCodes::InvalidOpenFlags, ErrorModule::FS,
|
||||
ErrorSummary::Canceled, ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_INVALID_READ_FLAG(ErrCodes::InvalidReadFlag, ErrorModule::FS,
|
||||
ErrorSummary::InvalidArgument, ErrorLevel::Usage);
|
||||
constexpr ResultCode ERROR_FILE_NOT_FOUND(ErrCodes::FileNotFound, ErrorModule::FS,
|
||||
ErrorSummary::NotFound, ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_PATH_NOT_FOUND(ErrCodes::PathNotFound, ErrorModule::FS,
|
||||
ErrorSummary::NotFound, ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_NOT_FOUND(ErrCodes::NotFound, ErrorModule::FS, ErrorSummary::NotFound,
|
||||
ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(ErrCodes::UnexpectedFileOrDirectory,
|
||||
ErrorModule::FS, ErrorSummary::NotSupported,
|
||||
ErrorLevel::Usage);
|
||||
constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY_SDMC(ErrCodes::NotAFile, ErrorModule::FS,
|
||||
ErrorSummary::Canceled,
|
||||
ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(ErrCodes::DirectoryAlreadyExists,
|
||||
ErrorModule::FS, ErrorSummary::NothingHappened,
|
||||
ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(ErrCodes::FileAlreadyExists, ErrorModule::FS,
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_ALREADY_EXISTS(ErrCodes::AlreadyExists, ErrorModule::FS,
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(ErrCodes::DirectoryNotEmpty, ErrorModule::FS,
|
||||
ErrorSummary::Canceled, ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_GAMECARD_NOT_INSERTED(ErrCodes::GameCardNotInserted, ErrorModule::FS,
|
||||
ErrorSummary::NotFound, ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_INCORRECT_EXEFS_READ_SIZE(ErrCodes::IncorrectExeFSReadSize,
|
||||
ErrorModule::FS, ErrorSummary::NotSupported,
|
||||
ErrorLevel::Usage);
|
||||
constexpr ResultCode ERROR_ROMFS_NOT_FOUND(ErrCodes::RomFSNotFound, ErrorModule::FS,
|
||||
constexpr Result ResultInvalidPath(ErrCodes::InvalidPath, ErrorModule::FS,
|
||||
ErrorSummary::InvalidArgument, ErrorLevel::Usage);
|
||||
constexpr Result ResultUnsupportedOpenFlags(ErrCodes::UnsupportedOpenFlags, ErrorModule::FS,
|
||||
ErrorSummary::NotSupported, ErrorLevel::Usage);
|
||||
constexpr Result ResultInvalidOpenFlags(ErrCodes::InvalidOpenFlags, ErrorModule::FS,
|
||||
ErrorSummary::Canceled, ErrorLevel::Status);
|
||||
constexpr Result ResultInvalidReadFlag(ErrCodes::InvalidReadFlag, ErrorModule::FS,
|
||||
ErrorSummary::InvalidArgument, ErrorLevel::Usage);
|
||||
constexpr Result ResultFileNotFound(ErrCodes::FileNotFound, ErrorModule::FS, ErrorSummary::NotFound,
|
||||
ErrorLevel::Status);
|
||||
constexpr Result ResultPathNotFound(ErrCodes::PathNotFound, ErrorModule::FS, ErrorSummary::NotFound,
|
||||
ErrorLevel::Status);
|
||||
constexpr Result ResultNotFound(ErrCodes::NotFound, ErrorModule::FS, ErrorSummary::NotFound,
|
||||
ErrorLevel::Status);
|
||||
constexpr Result ResultUnexpectedFileOrDirectory(ErrCodes::UnexpectedFileOrDirectory,
|
||||
ErrorModule::FS, ErrorSummary::NotSupported,
|
||||
ErrorLevel::Usage);
|
||||
constexpr Result ResultUnexpectedFileOrDirectorySdmc(ErrCodes::NotAFile, ErrorModule::FS,
|
||||
ErrorSummary::Canceled, ErrorLevel::Status);
|
||||
constexpr Result ResultDirectoryAlreadyExists(ErrCodes::DirectoryAlreadyExists, ErrorModule::FS,
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
constexpr Result ResultFileAlreadyExists(ErrCodes::FileAlreadyExists, ErrorModule::FS,
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
constexpr Result ResultAlreadyExists(ErrCodes::AlreadyExists, ErrorModule::FS,
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
constexpr Result ResultDirectoryNotEmpty(ErrCodes::DirectoryNotEmpty, ErrorModule::FS,
|
||||
ErrorSummary::Canceled, ErrorLevel::Status);
|
||||
constexpr Result ResultGamecardNotInserted(ErrCodes::GameCardNotInserted, ErrorModule::FS,
|
||||
ErrorSummary::NotFound, ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_COMMAND_NOT_ALLOWED(ErrCodes::CommandNotAllowed, ErrorModule::FS,
|
||||
ErrorSummary::WrongArgument, ErrorLevel::Permanent);
|
||||
constexpr ResultCode ERROR_EXEFS_SECTION_NOT_FOUND(ErrCodes::ExeFSSectionNotFound, ErrorModule::FS,
|
||||
ErrorSummary::NotFound, ErrorLevel::Status);
|
||||
constexpr ResultCode ERROR_INSUFFICIENT_SPACE(ErrCodes::InsufficientSpace, ErrorModule::FS,
|
||||
ErrorSummary::OutOfResource, ErrorLevel::Status);
|
||||
constexpr Result ResultIncorrectExefsReadSize(ErrCodes::IncorrectExeFSReadSize, ErrorModule::FS,
|
||||
ErrorSummary::NotSupported, ErrorLevel::Usage);
|
||||
constexpr Result ResultRomfsNotFound(ErrCodes::RomFSNotFound, ErrorModule::FS,
|
||||
ErrorSummary::NotFound, ErrorLevel::Status);
|
||||
constexpr Result ResultCommandNotAllowed(ErrCodes::CommandNotAllowed, ErrorModule::FS,
|
||||
ErrorSummary::WrongArgument, ErrorLevel::Permanent);
|
||||
constexpr Result ResultExefsSectionNotFound(ErrCodes::ExeFSSectionNotFound, ErrorModule::FS,
|
||||
ErrorSummary::NotFound, ErrorLevel::Status);
|
||||
constexpr Result ResultInsufficientSpace(ErrCodes::InsufficientSpace, ErrorModule::FS,
|
||||
ErrorSummary::OutOfResource, ErrorLevel::Status);
|
||||
|
||||
/// Returned when a function is passed an invalid archive handle.
|
||||
constexpr ResultCode ERR_INVALID_ARCHIVE_HANDLE(ErrCodes::ArchiveNotMounted, ErrorModule::FS,
|
||||
ErrorSummary::NotFound,
|
||||
ErrorLevel::Status); // 0xC8804465
|
||||
constexpr ResultCode ERR_WRITE_BEYOND_END(ErrCodes::WriteBeyondEnd, ErrorModule::FS,
|
||||
ErrorSummary::InvalidArgument, ErrorLevel::Usage);
|
||||
constexpr Result ResultInvalidArchiveHandle(ErrCodes::ArchiveNotMounted, ErrorModule::FS,
|
||||
ErrorSummary::NotFound,
|
||||
ErrorLevel::Status); // 0xC8804465
|
||||
constexpr Result ResultWriteBeyondEnd(ErrCodes::WriteBeyondEnd, ErrorModule::FS,
|
||||
ErrorSummary::InvalidArgument, ErrorLevel::Usage);
|
||||
|
||||
/**
|
||||
* Variant of ERROR_NOT_FOUND returned in some places in the code. Unknown if these usages are
|
||||
* Variant of ResultNotFound returned in some places in the code. Unknown if these usages are
|
||||
* correct or a bug.
|
||||
*/
|
||||
constexpr ResultCode ERR_NOT_FOUND_INVALID_STATE(ErrCodes::NotFound, ErrorModule::FS,
|
||||
ErrorSummary::InvalidState, ErrorLevel::Status);
|
||||
constexpr ResultCode ERR_NOT_FORMATTED(ErrCodes::NotFormatted, ErrorModule::FS,
|
||||
ErrorSummary::InvalidState, ErrorLevel::Status);
|
||||
constexpr Result ResultNotFoundInvalidState(ErrCodes::NotFound, ErrorModule::FS,
|
||||
ErrorSummary::InvalidState, ErrorLevel::Status);
|
||||
constexpr Result ResultNotFormatted(ErrCodes::NotFormatted, ErrorModule::FS,
|
||||
ErrorSummary::InvalidState, ErrorLevel::Status);
|
||||
|
||||
} // namespace FileSys
|
||||
|
@ -34,50 +34,50 @@ ResultVal<std::unique_ptr<FileBackend>> IVFCArchive::OpenFile(const Path& path,
|
||||
return std::make_unique<IVFCFile>(romfs_file, std::move(delay_generator));
|
||||
}
|
||||
|
||||
ResultCode IVFCArchive::DeleteFile(const Path& path) const {
|
||||
Result IVFCArchive::DeleteFile(const Path& path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to delete a file from an IVFC archive ({}).", GetName());
|
||||
// TODO(Subv): Verify error code
|
||||
return ResultCode(ErrorDescription::NoData, ErrorModule::FS, ErrorSummary::Canceled,
|
||||
ErrorLevel::Status);
|
||||
return Result(ErrorDescription::NoData, ErrorModule::FS, ErrorSummary::Canceled,
|
||||
ErrorLevel::Status);
|
||||
}
|
||||
|
||||
ResultCode IVFCArchive::RenameFile(const Path& src_path, const Path& dest_path) const {
|
||||
Result IVFCArchive::RenameFile(const Path& src_path, const Path& dest_path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to rename a file within an IVFC archive ({}).", GetName());
|
||||
// TODO(wwylele): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultCode IVFCArchive::DeleteDirectory(const Path& path) const {
|
||||
Result IVFCArchive::DeleteDirectory(const Path& path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to delete a directory from an IVFC archive ({}).",
|
||||
GetName());
|
||||
// TODO(wwylele): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultCode IVFCArchive::DeleteDirectoryRecursively(const Path& path) const {
|
||||
Result IVFCArchive::DeleteDirectoryRecursively(const Path& path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to delete a directory from an IVFC archive ({}).",
|
||||
GetName());
|
||||
// TODO(wwylele): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultCode IVFCArchive::CreateFile(const Path& path, u64 size) const {
|
||||
Result IVFCArchive::CreateFile(const Path& path, u64 size) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to create a file in an IVFC archive ({}).", GetName());
|
||||
// TODO: Verify error code
|
||||
return ResultCode(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
|
||||
ErrorLevel::Permanent);
|
||||
return Result(ErrorDescription::NotAuthorized, ErrorModule::FS, ErrorSummary::NotSupported,
|
||||
ErrorLevel::Permanent);
|
||||
}
|
||||
|
||||
ResultCode IVFCArchive::CreateDirectory(const Path& path) const {
|
||||
Result IVFCArchive::CreateDirectory(const Path& path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to create a directory in an IVFC archive ({}).", GetName());
|
||||
// TODO(wwylele): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultCode IVFCArchive::RenameDirectory(const Path& src_path, const Path& dest_path) const {
|
||||
Result IVFCArchive::RenameDirectory(const Path& src_path, const Path& dest_path) const {
|
||||
LOG_CRITICAL(Service_FS, "Attempted to rename a file within an IVFC archive ({}).", GetName());
|
||||
// TODO(wwylele): Use correct error code
|
||||
return RESULT_UNKNOWN;
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<DirectoryBackend>> IVFCArchive::OpenDirectory(const Path& path) const {
|
||||
|
@ -103,13 +103,13 @@ public:
|
||||
|
||||
ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path,
|
||||
const Mode& mode) const override;
|
||||
ResultCode DeleteFile(const Path& path) const override;
|
||||
ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
|
||||
ResultCode DeleteDirectory(const Path& path) const override;
|
||||
ResultCode DeleteDirectoryRecursively(const Path& path) const override;
|
||||
ResultCode CreateFile(const Path& path, u64 size) const override;
|
||||
ResultCode CreateDirectory(const Path& path) const override;
|
||||
ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
|
||||
Result DeleteFile(const Path& path) const override;
|
||||
Result RenameFile(const Path& src_path, const Path& dest_path) const override;
|
||||
Result DeleteDirectory(const Path& path) const override;
|
||||
Result DeleteDirectoryRecursively(const Path& path) const override;
|
||||
Result CreateFile(const Path& path, u64 size) const override;
|
||||
Result CreateDirectory(const Path& path) const override;
|
||||
Result RenameDirectory(const Path& src_path, const Path& dest_path) const override;
|
||||
ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override;
|
||||
u64 GetFreeBytes() const override;
|
||||
|
||||
|
@ -65,7 +65,7 @@ static bool ReadSection(std::vector<u8>& data_out, FileUtil::IOFile& file, std::
|
||||
|
||||
Loader::ResultStatus FileSys::Plugin3GXLoader::Load(
|
||||
Service::PLGLDR::PLG_LDR::PluginLoaderContext& plg_context, Kernel::Process& process,
|
||||
Kernel::KernelSystem& kernel) {
|
||||
Kernel::KernelSystem& kernel, Service::PLGLDR::PLG_LDR& plg_ldr) {
|
||||
FileUtil::IOFile file(plg_context.plugin_path, "rb");
|
||||
if (!file.IsOpen()) {
|
||||
LOG_ERROR(Service_PLGLDR, "Failed to load 3GX plugin. Not found: {}",
|
||||
@ -158,12 +158,12 @@ Loader::ResultStatus FileSys::Plugin3GXLoader::Load(
|
||||
return Loader::ResultStatus::Error;
|
||||
}
|
||||
|
||||
return Map(plg_context, process, kernel);
|
||||
return Map(plg_context, process, kernel, plg_ldr);
|
||||
}
|
||||
|
||||
Loader::ResultStatus FileSys::Plugin3GXLoader::Map(
|
||||
Service::PLGLDR::PLG_LDR::PluginLoaderContext& plg_context, Kernel::Process& process,
|
||||
Kernel::KernelSystem& kernel) {
|
||||
Kernel::KernelSystem& kernel, Service::PLGLDR::PLG_LDR& plg_ldr) {
|
||||
|
||||
// Verify exe load checksum function is available
|
||||
if (exe_load_func.empty() && plg_context.load_exe_func.empty()) {
|
||||
@ -195,7 +195,7 @@ Loader::ResultStatus FileSys::Plugin3GXLoader::Map(
|
||||
return Loader::ResultStatus::ErrorMemoryAllocationFailed;
|
||||
}
|
||||
auto backing_memory_fb = kernel.memory.GetFCRAMRef(*offset_fb);
|
||||
Service::PLGLDR::PLG_LDR::SetPluginFBAddr(Memory::FCRAM_PADDR + *offset_fb);
|
||||
plg_ldr.SetPluginFBAddr(Memory::FCRAM_PADDR + *offset_fb);
|
||||
std::fill(backing_memory_fb.GetPtr(), backing_memory_fb.GetPtr() + _3GX_fb_size, 0);
|
||||
|
||||
auto vma_heap_fb = process.vm_manager.MapBackingMemory(
|
||||
|
@ -43,7 +43,8 @@ class FileBackend;
|
||||
class Plugin3GXLoader {
|
||||
public:
|
||||
Loader::ResultStatus Load(Service::PLGLDR::PLG_LDR::PluginLoaderContext& plg_context,
|
||||
Kernel::Process& process, Kernel::KernelSystem& kernel);
|
||||
Kernel::Process& process, Kernel::KernelSystem& kernel,
|
||||
Service::PLGLDR::PLG_LDR& plg_ldr);
|
||||
|
||||
struct PluginHeader {
|
||||
u32_le magic;
|
||||
@ -68,7 +69,8 @@ public:
|
||||
|
||||
private:
|
||||
Loader::ResultStatus Map(Service::PLGLDR::PLG_LDR::PluginLoaderContext& plg_context,
|
||||
Kernel::Process& process, Kernel::KernelSystem& kernel);
|
||||
Kernel::Process& process, Kernel::KernelSystem& kernel,
|
||||
Service::PLGLDR::PLG_LDR& plg_ldr);
|
||||
|
||||
static constexpr size_t bootloader_memory_size = 0x1000;
|
||||
static void MapBootloader(Kernel::Process& process, Kernel::KernelSystem& kernel,
|
||||
|
@ -43,17 +43,17 @@ ResultVal<std::unique_ptr<FileBackend>> SaveDataArchive::OpenFile(const Path& pa
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
if (mode.hex == 0) {
|
||||
LOG_ERROR(Service_FS, "Empty open mode");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
if (mode.create_flag && !mode.write_flag) {
|
||||
LOG_ERROR(Service_FS, "Create flag set but write flag not set");
|
||||
return ERROR_UNSUPPORTED_OPEN_FLAGS;
|
||||
return ResultUnsupportedOpenFlags;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -61,19 +61,19 @@ ResultVal<std::unique_ptr<FileBackend>> SaveDataArchive::OpenFile(const Path& pa
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_PATH_NOT_FOUND;
|
||||
return ResultPathNotFound;
|
||||
case PathParser::FileInPath:
|
||||
case PathParser::DirectoryFound:
|
||||
LOG_ERROR(Service_FS, "Unexpected file or directory in {}", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY;
|
||||
return ResultUnexpectedFileOrDirectory;
|
||||
case PathParser::NotFound:
|
||||
if (!mode.create_flag) {
|
||||
LOG_ERROR(Service_FS, "Non-existing file {} can't be open without mode create.",
|
||||
full_path);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
} else {
|
||||
// Create the file
|
||||
FileUtil::CreateEmptyFile(full_path);
|
||||
@ -86,19 +86,19 @@ ResultVal<std::unique_ptr<FileBackend>> SaveDataArchive::OpenFile(const Path& pa
|
||||
FileUtil::IOFile file(full_path, mode.write_flag ? "r+b" : "rb");
|
||||
if (!file.IsOpen()) {
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Unknown error opening {}", full_path);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
}
|
||||
|
||||
std::unique_ptr<DelayGenerator> delay_generator = std::make_unique<SaveDataDelayGenerator>();
|
||||
return std::make_unique<DiskFile>(std::move(file), mode, std::move(delay_generator));
|
||||
}
|
||||
|
||||
ResultCode SaveDataArchive::DeleteFile(const Path& path) const {
|
||||
Result SaveDataArchive::DeleteFile(const Path& path) const {
|
||||
const PathParser path_parser(path);
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -106,110 +106,109 @@ ResultCode SaveDataArchive::DeleteFile(const Path& path) const {
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_PATH_NOT_FOUND;
|
||||
return ResultPathNotFound;
|
||||
case PathParser::FileInPath:
|
||||
case PathParser::DirectoryFound:
|
||||
case PathParser::NotFound:
|
||||
LOG_ERROR(Service_FS, "File not found {}", full_path);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
case PathParser::FileFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
|
||||
if (FileUtil::Delete(full_path)) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Unknown error deleting {}", full_path);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
}
|
||||
|
||||
ResultCode SaveDataArchive::RenameFile(const Path& src_path, const Path& dest_path) const {
|
||||
Result SaveDataArchive::RenameFile(const Path& src_path, const Path& dest_path) const {
|
||||
const PathParser path_parser_src(src_path);
|
||||
|
||||
// TODO: Verify these return codes with HW
|
||||
if (!path_parser_src.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid src path {}", src_path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const PathParser path_parser_dest(dest_path);
|
||||
|
||||
if (!path_parser_dest.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid dest path {}", dest_path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto src_path_full = path_parser_src.BuildHostPath(mount_point);
|
||||
const auto dest_path_full = path_parser_dest.BuildHostPath(mount_point);
|
||||
|
||||
if (FileUtil::Rename(src_path_full, dest_path_full)) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
// TODO(yuriks): This code probably isn't right, it'll return a Status even if the file didn't
|
||||
// exist or similar. Verify.
|
||||
return ResultCode(ErrorDescription::NoData, ErrorModule::FS, // TODO: verify description
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
return Result(ErrorDescription::NoData, ErrorModule::FS, // TODO: verify description
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
static ResultCode DeleteDirectoryHelper(const Path& path, const std::string& mount_point,
|
||||
T deleter) {
|
||||
static Result DeleteDirectoryHelper(const Path& path, const std::string& mount_point, T deleter) {
|
||||
const PathParser path_parser(path);
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
if (path_parser.IsRootDirectory())
|
||||
return ERROR_DIRECTORY_NOT_EMPTY;
|
||||
return ResultDirectoryNotEmpty;
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_PATH_NOT_FOUND;
|
||||
return ResultPathNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
case PathParser::NotFound:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_PATH_NOT_FOUND;
|
||||
return ResultPathNotFound;
|
||||
case PathParser::FileInPath:
|
||||
case PathParser::FileFound:
|
||||
LOG_ERROR(Service_FS, "Unexpected file or directory {}", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY;
|
||||
return ResultUnexpectedFileOrDirectory;
|
||||
case PathParser::DirectoryFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
|
||||
if (deleter(full_path)) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
LOG_ERROR(Service_FS, "Directory not empty {}", full_path);
|
||||
return ERROR_DIRECTORY_NOT_EMPTY;
|
||||
return ResultDirectoryNotEmpty;
|
||||
}
|
||||
|
||||
ResultCode SaveDataArchive::DeleteDirectory(const Path& path) const {
|
||||
Result SaveDataArchive::DeleteDirectory(const Path& path) const {
|
||||
return DeleteDirectoryHelper(path, mount_point, FileUtil::DeleteDir);
|
||||
}
|
||||
|
||||
ResultCode SaveDataArchive::DeleteDirectoryRecursively(const Path& path) const {
|
||||
Result SaveDataArchive::DeleteDirectoryRecursively(const Path& path) const {
|
||||
return DeleteDirectoryHelper(
|
||||
path, mount_point, [](const std::string& p) { return FileUtil::DeleteDirRecursively(p); });
|
||||
}
|
||||
|
||||
ResultCode SaveDataArchive::CreateFile(const FileSys::Path& path, u64 size) const {
|
||||
Result SaveDataArchive::CreateFile(const FileSys::Path& path, u64 size) const {
|
||||
const PathParser path_parser(path);
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -217,44 +216,44 @@ ResultCode SaveDataArchive::CreateFile(const FileSys::Path& path, u64 size) cons
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_PATH_NOT_FOUND;
|
||||
return ResultPathNotFound;
|
||||
case PathParser::FileInPath:
|
||||
LOG_ERROR(Service_FS, "Unexpected file in path {}", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY;
|
||||
return ResultUnexpectedFileOrDirectory;
|
||||
case PathParser::DirectoryFound:
|
||||
case PathParser::FileFound:
|
||||
LOG_ERROR(Service_FS, "{} already exists", full_path);
|
||||
return ERROR_FILE_ALREADY_EXISTS;
|
||||
return ResultFileAlreadyExists;
|
||||
case PathParser::NotFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
|
||||
if (size == 0) {
|
||||
FileUtil::CreateEmptyFile(full_path);
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
FileUtil::IOFile file(full_path, "wb");
|
||||
// Creates a sparse file (or a normal file on filesystems without the concept of sparse files)
|
||||
// We do this by seeking to the right size, then writing a single null byte.
|
||||
if (file.Seek(size - 1, SEEK_SET) && file.WriteBytes("", 1) == 1) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
LOG_ERROR(Service_FS, "Too large file");
|
||||
return ResultCode(ErrorDescription::TooLarge, ErrorModule::FS, ErrorSummary::OutOfResource,
|
||||
ErrorLevel::Info);
|
||||
return Result(ErrorDescription::TooLarge, ErrorModule::FS, ErrorSummary::OutOfResource,
|
||||
ErrorLevel::Info);
|
||||
}
|
||||
|
||||
ResultCode SaveDataArchive::CreateDirectory(const Path& path) const {
|
||||
Result SaveDataArchive::CreateDirectory(const Path& path) const {
|
||||
const PathParser path_parser(path);
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -262,57 +261,57 @@ ResultCode SaveDataArchive::CreateDirectory(const Path& path) const {
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_PATH_NOT_FOUND;
|
||||
return ResultPathNotFound;
|
||||
case PathParser::FileInPath:
|
||||
LOG_ERROR(Service_FS, "Unexpected file in path {}", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY;
|
||||
return ResultUnexpectedFileOrDirectory;
|
||||
case PathParser::DirectoryFound:
|
||||
case PathParser::FileFound:
|
||||
LOG_ERROR(Service_FS, "{} already exists", full_path);
|
||||
return ERROR_DIRECTORY_ALREADY_EXISTS;
|
||||
return ResultDirectoryAlreadyExists;
|
||||
case PathParser::NotFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
|
||||
if (FileUtil::CreateDir(mount_point + path.AsString())) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Unknown error creating {}", mount_point);
|
||||
return ResultCode(ErrorDescription::NoData, ErrorModule::FS, ErrorSummary::Canceled,
|
||||
ErrorLevel::Status);
|
||||
return Result(ErrorDescription::NoData, ErrorModule::FS, ErrorSummary::Canceled,
|
||||
ErrorLevel::Status);
|
||||
}
|
||||
|
||||
ResultCode SaveDataArchive::RenameDirectory(const Path& src_path, const Path& dest_path) const {
|
||||
Result SaveDataArchive::RenameDirectory(const Path& src_path, const Path& dest_path) const {
|
||||
const PathParser path_parser_src(src_path);
|
||||
|
||||
// TODO: Verify these return codes with HW
|
||||
if (!path_parser_src.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid src path {}", src_path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const PathParser path_parser_dest(dest_path);
|
||||
|
||||
if (!path_parser_dest.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid dest path {}", dest_path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto src_path_full = path_parser_src.BuildHostPath(mount_point);
|
||||
const auto dest_path_full = path_parser_dest.BuildHostPath(mount_point);
|
||||
|
||||
if (FileUtil::Rename(src_path_full, dest_path_full)) {
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
// TODO(yuriks): This code probably isn't right, it'll return a Status even if the file didn't
|
||||
// exist or similar. Verify.
|
||||
return ResultCode(ErrorDescription::NoData, ErrorModule::FS, // TODO: verify description
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
return Result(ErrorDescription::NoData, ErrorModule::FS, // TODO: verify description
|
||||
ErrorSummary::NothingHappened, ErrorLevel::Status);
|
||||
}
|
||||
|
||||
ResultVal<std::unique_ptr<DirectoryBackend>> SaveDataArchive::OpenDirectory(
|
||||
@ -321,7 +320,7 @@ ResultVal<std::unique_ptr<DirectoryBackend>> SaveDataArchive::OpenDirectory(
|
||||
|
||||
if (!path_parser.IsValid()) {
|
||||
LOG_ERROR(Service_FS, "Invalid path {}", path.DebugStr());
|
||||
return ERROR_INVALID_PATH;
|
||||
return ResultInvalidPath;
|
||||
}
|
||||
|
||||
const auto full_path = path_parser.BuildHostPath(mount_point);
|
||||
@ -329,15 +328,15 @@ ResultVal<std::unique_ptr<DirectoryBackend>> SaveDataArchive::OpenDirectory(
|
||||
switch (path_parser.GetHostStatus(mount_point)) {
|
||||
case PathParser::InvalidMountPoint:
|
||||
LOG_CRITICAL(Service_FS, "(unreachable) Invalid mount point {}", mount_point);
|
||||
return ERROR_FILE_NOT_FOUND;
|
||||
return ResultFileNotFound;
|
||||
case PathParser::PathNotFound:
|
||||
case PathParser::NotFound:
|
||||
LOG_ERROR(Service_FS, "Path not found {}", full_path);
|
||||
return ERROR_PATH_NOT_FOUND;
|
||||
return ResultPathNotFound;
|
||||
case PathParser::FileInPath:
|
||||
case PathParser::FileFound:
|
||||
LOG_ERROR(Service_FS, "Unexpected file in path {}", full_path);
|
||||
return ERROR_UNEXPECTED_FILE_OR_DIRECTORY;
|
||||
return ResultUnexpectedFileOrDirectory;
|
||||
case PathParser::DirectoryFound:
|
||||
break; // Expected 'success' case
|
||||
}
|
||||
|
@ -23,13 +23,13 @@ public:
|
||||
|
||||
ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path,
|
||||
const Mode& mode) const override;
|
||||
ResultCode DeleteFile(const Path& path) const override;
|
||||
ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
|
||||
ResultCode DeleteDirectory(const Path& path) const override;
|
||||
ResultCode DeleteDirectoryRecursively(const Path& path) const override;
|
||||
ResultCode CreateFile(const Path& path, u64 size) const override;
|
||||
ResultCode CreateDirectory(const Path& path) const override;
|
||||
ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
|
||||
Result DeleteFile(const Path& path) const override;
|
||||
Result RenameFile(const Path& src_path, const Path& dest_path) const override;
|
||||
Result DeleteDirectory(const Path& path) const override;
|
||||
Result DeleteDirectoryRecursively(const Path& path) const override;
|
||||
Result CreateFile(const Path& path, u64 size) const override;
|
||||
Result CreateDirectory(const Path& path) const override;
|
||||
Result RenameDirectory(const Path& src_path, const Path& dest_path) const override;
|
||||
ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override;
|
||||
u64 GetFreeBytes() const override;
|
||||
|
||||
|
@ -9,7 +9,7 @@
|
||||
|
||||
namespace Frontend {
|
||||
void RegisterDefaultApplets(Core::System& system) {
|
||||
system.RegisterSoftwareKeyboard(std::make_shared<DefaultKeyboard>());
|
||||
system.RegisterSoftwareKeyboard(std::make_shared<DefaultKeyboard>(system));
|
||||
system.RegisterMiiSelector(std::make_shared<DefaultMiiSelector>());
|
||||
}
|
||||
} // namespace Frontend
|
||||
|
@ -144,10 +144,12 @@ const KeyboardData& SoftwareKeyboard::ReceiveData() {
|
||||
return data;
|
||||
}
|
||||
|
||||
DefaultKeyboard::DefaultKeyboard(Core::System& system_) : system(system_) {}
|
||||
|
||||
void DefaultKeyboard::Execute(const Frontend::KeyboardConfig& config_) {
|
||||
SoftwareKeyboard::Execute(config_);
|
||||
|
||||
auto cfg = Service::CFG::GetModule(Core::System::GetInstance());
|
||||
auto cfg = Service::CFG::GetModule(system);
|
||||
std::string username = Common::UTF16ToUTF8(cfg->GetUsername());
|
||||
switch (this->config.button_config) {
|
||||
case ButtonConfig::None:
|
||||
|
@ -8,6 +8,10 @@
|
||||
#include <vector>
|
||||
#include "common/assert.h"
|
||||
|
||||
namespace Core {
|
||||
class System;
|
||||
}
|
||||
|
||||
namespace Frontend {
|
||||
|
||||
enum class AcceptedInput {
|
||||
@ -137,8 +141,12 @@ protected:
|
||||
|
||||
class DefaultKeyboard final : public SoftwareKeyboard {
|
||||
public:
|
||||
explicit DefaultKeyboard(Core::System& system_);
|
||||
void Execute(const KeyboardConfig& config) override;
|
||||
void ShowError(const std::string& error) override;
|
||||
|
||||
private:
|
||||
Core::System& system;
|
||||
};
|
||||
|
||||
} // namespace Frontend
|
||||
|
@ -173,8 +173,7 @@ void EmuWindow::TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y) {
|
||||
TouchPressed(framebuffer_x, framebuffer_y);
|
||||
}
|
||||
|
||||
void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height,
|
||||
bool is_portrait_mode) {
|
||||
void EmuWindow::UpdateCurrentFramebufferLayout(u32 width, u32 height, bool is_portrait_mode) {
|
||||
Layout::FramebufferLayout layout;
|
||||
|
||||
// If in portrait mode, only the MobilePortrait option really makes sense
|
||||
@ -200,7 +199,8 @@ void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height,
|
||||
layout =
|
||||
Layout::LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
|
||||
Settings::values.upright_screen.GetValue(),
|
||||
Settings::values.large_screen_proportion.GetValue());
|
||||
Settings::values.large_screen_proportion.GetValue(),
|
||||
Layout::VerticalAlignment::Bottom);
|
||||
break;
|
||||
case Settings::LayoutOption::HybridScreen:
|
||||
layout =
|
||||
@ -208,8 +208,10 @@ void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height,
|
||||
Settings::values.upright_screen.GetValue());
|
||||
break;
|
||||
case Settings::LayoutOption::SideScreen:
|
||||
layout = Layout::SideFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
|
||||
Settings::values.upright_screen.GetValue());
|
||||
layout =
|
||||
Layout::LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
|
||||
Settings::values.upright_screen.GetValue(), 1.0f,
|
||||
Layout::VerticalAlignment::Bottom);
|
||||
break;
|
||||
#ifndef ANDROID
|
||||
case Settings::LayoutOption::SeparateWindows:
|
||||
@ -222,8 +224,9 @@ void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height,
|
||||
Settings::values.swap_screen.GetValue());
|
||||
break;
|
||||
case Settings::LayoutOption::MobileLandscape:
|
||||
layout = Layout::MobileLandscapeFrameLayout(
|
||||
width, height, Settings::values.swap_screen.GetValue(), 2.25f, false);
|
||||
layout =
|
||||
Layout::LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
|
||||
false, 2.25f, Layout::VerticalAlignment::Top);
|
||||
break;
|
||||
case Settings::LayoutOption::Default:
|
||||
default:
|
||||
|
@ -30,7 +30,7 @@ u32 FramebufferLayout::GetScalingRatio() const {
|
||||
|
||||
// Finds the largest size subrectangle contained in window area that is confined to the aspect ratio
|
||||
template <class T>
|
||||
static Common::Rectangle<T> maxRectangle(Common::Rectangle<T> window_area,
|
||||
static Common::Rectangle<T> MaxRectangle(Common::Rectangle<T> window_area,
|
||||
float screen_aspect_ratio) {
|
||||
float scale = std::min(static_cast<float>(window_area.GetWidth()),
|
||||
window_area.GetHeight() / screen_aspect_ratio);
|
||||
@ -50,15 +50,15 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool swapped, bool u
|
||||
if (upright) {
|
||||
// Default layout gives equal screen sizes to the top and bottom screen
|
||||
screen_window_area = {0, 0, width / 2, height};
|
||||
top_screen = maxRectangle(screen_window_area, TOP_SCREEN_UPRIGHT_ASPECT_RATIO);
|
||||
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO);
|
||||
top_screen = MaxRectangle(screen_window_area, TOP_SCREEN_UPRIGHT_ASPECT_RATIO);
|
||||
bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO);
|
||||
// both screens width are taken into account by dividing by 2
|
||||
emulation_aspect_ratio = TOP_SCREEN_UPRIGHT_ASPECT_RATIO / 2;
|
||||
} else {
|
||||
// Default layout gives equal screen sizes to the top and bottom screen
|
||||
screen_window_area = {0, 0, width, height / 2};
|
||||
top_screen = maxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
|
||||
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
|
||||
top_screen = MaxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
|
||||
bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
|
||||
// both screens height are taken into account by multiplying by 2
|
||||
emulation_aspect_ratio = TOP_SCREEN_ASPECT_RATIO * 2;
|
||||
}
|
||||
@ -71,7 +71,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool swapped, bool u
|
||||
// Recalculate the bottom screen to account for the height difference between right and
|
||||
// left
|
||||
screen_window_area = {0, 0, top_screen.GetWidth(), height};
|
||||
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO);
|
||||
bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO);
|
||||
bot_screen =
|
||||
bot_screen.TranslateY((top_screen.GetHeight() - bot_screen.GetHeight()) / 2);
|
||||
if (swapped) {
|
||||
@ -96,7 +96,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool swapped, bool u
|
||||
// Recalculate the bottom screen to account for the width difference between top and
|
||||
// bottom
|
||||
screen_window_area = {0, 0, width, top_screen.GetHeight()};
|
||||
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
|
||||
bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
|
||||
bot_screen = bot_screen.TranslateX((top_screen.GetWidth() - bot_screen.GetWidth()) / 2);
|
||||
if (swapped) {
|
||||
bot_screen = bot_screen.TranslateY(height / 2 - bot_screen.GetHeight());
|
||||
@ -124,8 +124,8 @@ FramebufferLayout MobilePortraitFrameLayout(u32 width, u32 height, bool swapped)
|
||||
FramebufferLayout res{width, height, true, true, {}, {}};
|
||||
// Default layout gives equal screen sizes to the top and bottom screen
|
||||
Common::Rectangle<u32> screen_window_area{0, 0, width, height / 2};
|
||||
Common::Rectangle<u32> top_screen = maxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
|
||||
Common::Rectangle<u32> bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
|
||||
Common::Rectangle<u32> top_screen = MaxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
|
||||
Common::Rectangle<u32> bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
|
||||
|
||||
float window_aspect_ratio = static_cast<float>(height) / width;
|
||||
// both screens height are taken into account by multiplying by 2
|
||||
@ -151,48 +151,6 @@ FramebufferLayout MobilePortraitFrameLayout(u32 width, u32 height, bool swapped)
|
||||
return res;
|
||||
}
|
||||
|
||||
FramebufferLayout MobileLandscapeFrameLayout(u32 width, u32 height, bool swapped,
|
||||
float scale_factor, bool center_vertical) {
|
||||
ASSERT(width > 0);
|
||||
ASSERT(height > 0);
|
||||
|
||||
FramebufferLayout res{width, height, true, true, {}, {}};
|
||||
// Split the window into two parts. Give 4x width to the main screen and 1x width to the small
|
||||
// To do that, find the total emulation box and maximize that based on window size
|
||||
float window_aspect_ratio = static_cast<float>(height) / width;
|
||||
float emulation_aspect_ratio =
|
||||
swapped ? Core::kScreenBottomHeight * scale_factor /
|
||||
(Core::kScreenBottomWidth * scale_factor + Core::kScreenTopWidth)
|
||||
: Core::kScreenTopHeight * scale_factor /
|
||||
(Core::kScreenTopWidth * scale_factor + Core::kScreenBottomWidth);
|
||||
float large_screen_aspect_ratio = swapped ? BOT_SCREEN_ASPECT_RATIO : TOP_SCREEN_ASPECT_RATIO;
|
||||
float small_screen_aspect_ratio = swapped ? TOP_SCREEN_ASPECT_RATIO : BOT_SCREEN_ASPECT_RATIO;
|
||||
|
||||
Common::Rectangle<u32> screen_window_area{0, 0, width, height};
|
||||
Common::Rectangle<u32> total_rect = maxRectangle(screen_window_area, emulation_aspect_ratio);
|
||||
Common::Rectangle<u32> large_screen = maxRectangle(total_rect, large_screen_aspect_ratio);
|
||||
Common::Rectangle<u32> fourth_size_rect = total_rect.Scale(1.f / scale_factor);
|
||||
Common::Rectangle<u32> small_screen = maxRectangle(fourth_size_rect, small_screen_aspect_ratio);
|
||||
|
||||
if (window_aspect_ratio < emulation_aspect_ratio) {
|
||||
large_screen =
|
||||
large_screen.TranslateX((screen_window_area.GetWidth() - total_rect.GetWidth()) / 2);
|
||||
} else if (center_vertical) {
|
||||
large_screen = large_screen.TranslateY((height - total_rect.GetHeight()) / 2);
|
||||
}
|
||||
|
||||
// Shift the small screen to the bottom right corner
|
||||
small_screen = small_screen.TranslateX(large_screen.right);
|
||||
if (center_vertical) {
|
||||
small_screen = small_screen.TranslateY(large_screen.GetHeight() + large_screen.top -
|
||||
small_screen.GetHeight());
|
||||
}
|
||||
|
||||
res.top_screen = swapped ? small_screen : large_screen;
|
||||
res.bottom_screen = swapped ? large_screen : small_screen;
|
||||
return res;
|
||||
}
|
||||
|
||||
FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool swapped, bool upright) {
|
||||
ASSERT(width > 0);
|
||||
ASSERT(height > 0);
|
||||
@ -205,13 +163,13 @@ FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool swapped, bool up
|
||||
Common::Rectangle<u32> bot_screen;
|
||||
float emulation_aspect_ratio;
|
||||
if (upright) {
|
||||
top_screen = maxRectangle(screen_window_area, TOP_SCREEN_UPRIGHT_ASPECT_RATIO);
|
||||
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO);
|
||||
top_screen = MaxRectangle(screen_window_area, TOP_SCREEN_UPRIGHT_ASPECT_RATIO);
|
||||
bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO);
|
||||
emulation_aspect_ratio =
|
||||
(swapped) ? BOT_SCREEN_UPRIGHT_ASPECT_RATIO : TOP_SCREEN_UPRIGHT_ASPECT_RATIO;
|
||||
} else {
|
||||
top_screen = maxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
|
||||
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
|
||||
top_screen = MaxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
|
||||
bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
|
||||
emulation_aspect_ratio = (swapped) ? BOT_SCREEN_ASPECT_RATIO : TOP_SCREEN_ASPECT_RATIO;
|
||||
}
|
||||
|
||||
@ -232,7 +190,7 @@ FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool swapped, bool up
|
||||
}
|
||||
|
||||
FramebufferLayout LargeFrameLayout(u32 width, u32 height, bool swapped, bool upright,
|
||||
float scale_factor) {
|
||||
float scale_factor, VerticalAlignment vertical_alignment) {
|
||||
ASSERT(width > 0);
|
||||
ASSERT(height > 0);
|
||||
|
||||
@ -274,10 +232,10 @@ FramebufferLayout LargeFrameLayout(u32 width, u32 height, bool swapped, bool upr
|
||||
}
|
||||
|
||||
Common::Rectangle<u32> screen_window_area{0, 0, width, height};
|
||||
Common::Rectangle<u32> total_rect = maxRectangle(screen_window_area, emulation_aspect_ratio);
|
||||
Common::Rectangle<u32> large_screen = maxRectangle(total_rect, large_screen_aspect_ratio);
|
||||
Common::Rectangle<u32> fourth_size_rect = total_rect.Scale(1.f / scale_factor);
|
||||
Common::Rectangle<u32> small_screen = maxRectangle(fourth_size_rect, small_screen_aspect_ratio);
|
||||
Common::Rectangle<u32> total_rect = MaxRectangle(screen_window_area, emulation_aspect_ratio);
|
||||
Common::Rectangle<u32> large_screen = MaxRectangle(total_rect, large_screen_aspect_ratio);
|
||||
Common::Rectangle<u32> scaled_rect = total_rect.Scale(1.f / scale_factor);
|
||||
Common::Rectangle<u32> small_screen = MaxRectangle(scaled_rect, small_screen_aspect_ratio);
|
||||
|
||||
if (window_aspect_ratio < emulation_aspect_ratio) {
|
||||
large_screen = large_screen.TranslateX((width - total_rect.GetWidth()) / 2);
|
||||
@ -286,13 +244,46 @@ FramebufferLayout LargeFrameLayout(u32 width, u32 height, bool swapped, bool upr
|
||||
}
|
||||
if (upright) {
|
||||
large_screen = large_screen.TranslateY(small_screen.GetHeight());
|
||||
small_screen = small_screen.TranslateX(large_screen.right - small_screen.GetWidth())
|
||||
.TranslateY(large_screen.top - small_screen.GetHeight());
|
||||
small_screen = small_screen.TranslateY(large_screen.top - small_screen.GetHeight());
|
||||
switch (vertical_alignment) {
|
||||
case VerticalAlignment::Top:
|
||||
// Shift the small screen to the top right corner
|
||||
small_screen = small_screen.TranslateX(large_screen.left);
|
||||
break;
|
||||
case VerticalAlignment::Middle:
|
||||
// Shift the small screen to the center right
|
||||
small_screen = small_screen.TranslateX(
|
||||
((large_screen.GetWidth() - small_screen.GetWidth()) / 2) + large_screen.left);
|
||||
break;
|
||||
case VerticalAlignment::Bottom:
|
||||
// Shift the small screen to the bottom right corner
|
||||
small_screen = small_screen.TranslateX(large_screen.right - small_screen.GetWidth());
|
||||
break;
|
||||
default:
|
||||
UNREACHABLE();
|
||||
break;
|
||||
}
|
||||
|
||||
} else {
|
||||
// Shift the small screen to the bottom right corner
|
||||
small_screen =
|
||||
small_screen.TranslateX(large_screen.right)
|
||||
.TranslateY(large_screen.GetHeight() + large_screen.top - small_screen.GetHeight());
|
||||
small_screen = small_screen.TranslateX(large_screen.right);
|
||||
switch (vertical_alignment) {
|
||||
case VerticalAlignment::Top:
|
||||
// Shift the small screen to the top right corner
|
||||
small_screen = small_screen.TranslateY(large_screen.top);
|
||||
break;
|
||||
case VerticalAlignment::Middle:
|
||||
// Shift the small screen to the center right
|
||||
small_screen = small_screen.TranslateY(
|
||||
((large_screen.GetHeight() - small_screen.GetHeight()) / 2) + large_screen.top);
|
||||
break;
|
||||
case VerticalAlignment::Bottom:
|
||||
// Shift the small screen to the bottom right corner
|
||||
small_screen = small_screen.TranslateY(large_screen.bottom - small_screen.GetHeight());
|
||||
break;
|
||||
default:
|
||||
UNREACHABLE();
|
||||
break;
|
||||
}
|
||||
}
|
||||
res.top_screen = swapped ? small_screen : large_screen;
|
||||
res.bottom_screen = swapped ? large_screen : small_screen;
|
||||
@ -331,11 +322,11 @@ FramebufferLayout HybridScreenLayout(u32 width, u32 height, bool swapped, bool u
|
||||
}
|
||||
|
||||
Common::Rectangle<u32> screen_window_area{0, 0, width, height};
|
||||
Common::Rectangle<u32> total_rect = maxRectangle(screen_window_area, hybrid_area_aspect_ratio);
|
||||
Common::Rectangle<u32> large_main_screen = maxRectangle(total_rect, main_screen_aspect_ratio);
|
||||
Common::Rectangle<u32> total_rect = MaxRectangle(screen_window_area, hybrid_area_aspect_ratio);
|
||||
Common::Rectangle<u32> large_main_screen = MaxRectangle(total_rect, main_screen_aspect_ratio);
|
||||
Common::Rectangle<u32> side_rect = total_rect.Scale(1.f / scale_factor);
|
||||
Common::Rectangle<u32> small_top_screen = maxRectangle(side_rect, top_screen_aspect_ratio);
|
||||
Common::Rectangle<u32> small_bottom_screen = maxRectangle(side_rect, bot_screen_aspect_ratio);
|
||||
Common::Rectangle<u32> small_top_screen = MaxRectangle(side_rect, top_screen_aspect_ratio);
|
||||
Common::Rectangle<u32> small_bottom_screen = MaxRectangle(side_rect, bot_screen_aspect_ratio);
|
||||
|
||||
if (window_aspect_ratio < hybrid_area_aspect_ratio) {
|
||||
large_main_screen = large_main_screen.TranslateX((width - total_rect.GetWidth()) / 2);
|
||||
@ -373,54 +364,6 @@ FramebufferLayout HybridScreenLayout(u32 width, u32 height, bool swapped, bool u
|
||||
return res;
|
||||
}
|
||||
|
||||
FramebufferLayout SideFrameLayout(u32 width, u32 height, bool swapped, bool upright) {
|
||||
ASSERT(width > 0);
|
||||
ASSERT(height > 0);
|
||||
|
||||
FramebufferLayout res{width, height, true, true, {}, {}, !upright};
|
||||
|
||||
// Aspect ratio of both screens side by side
|
||||
float emulation_aspect_ratio =
|
||||
upright ? static_cast<float>(Core::kScreenTopWidth + Core::kScreenBottomWidth) /
|
||||
Core::kScreenTopHeight
|
||||
: static_cast<float>(Core::kScreenTopHeight) /
|
||||
(Core::kScreenTopWidth + Core::kScreenBottomWidth);
|
||||
|
||||
float window_aspect_ratio = static_cast<float>(height) / width;
|
||||
Common::Rectangle<u32> screen_window_area{0, 0, width, height};
|
||||
// Find largest Rectangle that can fit in the window size with the given aspect ratio
|
||||
Common::Rectangle<u32> screen_rect = maxRectangle(screen_window_area, emulation_aspect_ratio);
|
||||
// Find sizes of top and bottom screen
|
||||
Common::Rectangle<u32> top_screen =
|
||||
upright ? maxRectangle(screen_rect, TOP_SCREEN_UPRIGHT_ASPECT_RATIO)
|
||||
: maxRectangle(screen_rect, TOP_SCREEN_ASPECT_RATIO);
|
||||
Common::Rectangle<u32> bot_screen =
|
||||
upright ? maxRectangle(screen_rect, BOT_SCREEN_UPRIGHT_ASPECT_RATIO)
|
||||
: maxRectangle(screen_rect, BOT_SCREEN_ASPECT_RATIO);
|
||||
|
||||
if (window_aspect_ratio < emulation_aspect_ratio) {
|
||||
// Apply borders to the left and right sides of the window.
|
||||
u32 shift_horizontal = (screen_window_area.GetWidth() - screen_rect.GetWidth()) / 2;
|
||||
top_screen = top_screen.TranslateX(shift_horizontal);
|
||||
bot_screen = bot_screen.TranslateX(shift_horizontal);
|
||||
} else {
|
||||
// Window is narrower than the emulation content => apply borders to the top and bottom
|
||||
u32 shift_vertical = (screen_window_area.GetHeight() - screen_rect.GetHeight()) / 2;
|
||||
top_screen = top_screen.TranslateY(shift_vertical);
|
||||
bot_screen = bot_screen.TranslateY(shift_vertical);
|
||||
}
|
||||
if (upright) {
|
||||
// Leave the top screen at the top if we are swapped.
|
||||
res.top_screen = swapped ? top_screen : top_screen.TranslateY(bot_screen.GetHeight());
|
||||
res.bottom_screen = swapped ? bot_screen.TranslateY(top_screen.GetHeight()) : bot_screen;
|
||||
} else {
|
||||
// Move the top screen to the right if we are swapped.
|
||||
res.top_screen = swapped ? top_screen.TranslateX(bot_screen.GetWidth()) : top_screen;
|
||||
res.bottom_screen = swapped ? bot_screen : bot_screen.TranslateX(top_screen.GetWidth());
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
FramebufferLayout SeparateWindowsLayout(u32 width, u32 height, bool is_secondary, bool upright) {
|
||||
// When is_secondary is true, we disable the top screen, and enable the bottom screen.
|
||||
// The same logic is found in the SingleFrameLayout using the is_swapped bool.
|
||||
@ -454,131 +397,103 @@ FramebufferLayout CustomFrameLayout(u32 width, u32 height, bool is_swapped) {
|
||||
}
|
||||
|
||||
FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale, bool is_secondary) {
|
||||
FramebufferLayout layout;
|
||||
if (Settings::values.custom_layout.GetValue() == true) {
|
||||
layout = CustomFrameLayout(std::max(Settings::values.custom_top_right.GetValue(),
|
||||
Settings::values.custom_bottom_right.GetValue()),
|
||||
std::max(Settings::values.custom_top_bottom.GetValue(),
|
||||
Settings::values.custom_bottom_bottom.GetValue()),
|
||||
Settings::values.swap_screen.GetValue());
|
||||
} else {
|
||||
int width, height;
|
||||
switch (Settings::values.layout_option.GetValue()) {
|
||||
case Settings::LayoutOption::SingleScreen:
|
||||
return CustomFrameLayout(std::max(Settings::values.custom_top_right.GetValue(),
|
||||
Settings::values.custom_bottom_right.GetValue()),
|
||||
std::max(Settings::values.custom_top_bottom.GetValue(),
|
||||
Settings::values.custom_bottom_bottom.GetValue()),
|
||||
Settings::values.swap_screen.GetValue());
|
||||
}
|
||||
|
||||
int width, height;
|
||||
switch (Settings::values.layout_option.GetValue()) {
|
||||
case Settings::LayoutOption::SingleScreen:
|
||||
#ifndef ANDROID
|
||||
case Settings::LayoutOption::SeparateWindows:
|
||||
case Settings::LayoutOption::SeparateWindows:
|
||||
#endif
|
||||
{
|
||||
const bool swap_screens = is_secondary || Settings::values.swap_screen.GetValue();
|
||||
if (Settings::values.upright_screen.GetValue()) {
|
||||
if (swap_screens) {
|
||||
width = Core::kScreenBottomHeight * res_scale;
|
||||
height = Core::kScreenBottomWidth * res_scale;
|
||||
} else {
|
||||
width = Core::kScreenTopHeight * res_scale;
|
||||
height = Core::kScreenTopWidth * res_scale;
|
||||
}
|
||||
} else {
|
||||
if (swap_screens) {
|
||||
width = Core::kScreenBottomWidth * res_scale;
|
||||
height = Core::kScreenBottomHeight * res_scale;
|
||||
} else {
|
||||
width = Core::kScreenTopWidth * res_scale;
|
||||
height = Core::kScreenTopHeight * res_scale;
|
||||
}
|
||||
}
|
||||
layout = SingleFrameLayout(width, height, swap_screens,
|
||||
Settings::values.upright_screen.GetValue());
|
||||
break;
|
||||
}
|
||||
case Settings::LayoutOption::LargeScreen:
|
||||
if (Settings::values.upright_screen.GetValue()) {
|
||||
if (Settings::values.swap_screen.GetValue()) {
|
||||
width = Core::kScreenBottomHeight * res_scale;
|
||||
height =
|
||||
(Core::kScreenBottomWidth +
|
||||
static_cast<int>(Core::kScreenTopWidth /
|
||||
Settings::values.large_screen_proportion.GetValue())) *
|
||||
res_scale;
|
||||
} else {
|
||||
width = Core::kScreenTopHeight * res_scale;
|
||||
height =
|
||||
(Core::kScreenTopWidth +
|
||||
static_cast<int>(Core::kScreenBottomWidth /
|
||||
Settings::values.large_screen_proportion.GetValue())) *
|
||||
res_scale;
|
||||
}
|
||||
} else {
|
||||
if (Settings::values.swap_screen.GetValue()) {
|
||||
width = (Core::kScreenBottomWidth +
|
||||
Core::kScreenTopWidth /
|
||||
static_cast<int>(
|
||||
Settings::values.large_screen_proportion.GetValue())) *
|
||||
res_scale;
|
||||
height = Core::kScreenBottomHeight * res_scale;
|
||||
} else {
|
||||
width = (Core::kScreenTopWidth +
|
||||
Core::kScreenBottomWidth /
|
||||
static_cast<int>(
|
||||
Settings::values.large_screen_proportion.GetValue())) *
|
||||
res_scale;
|
||||
height = Core::kScreenTopHeight * res_scale;
|
||||
}
|
||||
}
|
||||
layout = LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
|
||||
Settings::values.upright_screen.GetValue(),
|
||||
Settings::values.large_screen_proportion.GetValue());
|
||||
break;
|
||||
case Settings::LayoutOption::SideScreen:
|
||||
if (Settings::values.upright_screen.GetValue()) {
|
||||
width = Core::kScreenTopHeight * res_scale;
|
||||
height = (Core::kScreenTopWidth + Core::kScreenBottomWidth) * res_scale;
|
||||
} else {
|
||||
width = (Core::kScreenTopWidth + Core::kScreenBottomWidth) * res_scale;
|
||||
height = Core::kScreenTopHeight * res_scale;
|
||||
}
|
||||
layout = SideFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
|
||||
Settings::values.upright_screen.GetValue());
|
||||
break;
|
||||
case Settings::LayoutOption::MobilePortrait:
|
||||
{
|
||||
const bool swap_screens = is_secondary || Settings::values.swap_screen.GetValue();
|
||||
if (swap_screens) {
|
||||
width = Core::kScreenBottomWidth * res_scale;
|
||||
height = Core::kScreenBottomHeight * res_scale;
|
||||
} else {
|
||||
width = Core::kScreenTopWidth * res_scale;
|
||||
height = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale;
|
||||
layout =
|
||||
MobilePortraitFrameLayout(width, height, Settings::values.swap_screen.GetValue());
|
||||
break;
|
||||
case Settings::LayoutOption::MobileLandscape:
|
||||
if (Settings::values.swap_screen.GetValue()) {
|
||||
width =
|
||||
(Core::kScreenBottomWidth + static_cast<int>(Core::kScreenTopWidth / 2.25f)) *
|
||||
res_scale;
|
||||
height = Core::kScreenBottomHeight * res_scale;
|
||||
} else {
|
||||
width =
|
||||
(Core::kScreenTopWidth + static_cast<int>(Core::kScreenBottomWidth / 2.25f)) *
|
||||
res_scale;
|
||||
height = Core::kScreenTopHeight * res_scale;
|
||||
}
|
||||
layout = MobileLandscapeFrameLayout(
|
||||
width, height, Settings::values.swap_screen.GetValue(), 2.25f, false);
|
||||
break;
|
||||
case Settings::LayoutOption::Default:
|
||||
default:
|
||||
if (Settings::values.upright_screen.GetValue()) {
|
||||
width = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale;
|
||||
height = Core::kScreenTopWidth * res_scale;
|
||||
} else {
|
||||
width = Core::kScreenTopWidth * res_scale;
|
||||
height = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale;
|
||||
}
|
||||
layout = DefaultFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
|
||||
Settings::values.upright_screen.GetValue());
|
||||
break;
|
||||
height = Core::kScreenTopHeight * res_scale;
|
||||
}
|
||||
if (Settings::values.upright_screen.GetValue()) {
|
||||
std::swap(width, height);
|
||||
}
|
||||
return SingleFrameLayout(width, height, swap_screens,
|
||||
Settings::values.upright_screen.GetValue());
|
||||
}
|
||||
if (Settings::values.render_3d.GetValue() == Settings::StereoRenderOption::CardboardVR) {
|
||||
layout = Layout::GetCardboardSettings(layout);
|
||||
|
||||
case Settings::LayoutOption::LargeScreen:
|
||||
if (Settings::values.swap_screen.GetValue()) {
|
||||
width = (Core::kScreenBottomWidth +
|
||||
Core::kScreenTopWidth /
|
||||
static_cast<int>(Settings::values.large_screen_proportion.GetValue())) *
|
||||
res_scale;
|
||||
height = Core::kScreenBottomHeight * res_scale;
|
||||
} else {
|
||||
width = (Core::kScreenTopWidth +
|
||||
Core::kScreenBottomWidth /
|
||||
static_cast<int>(Settings::values.large_screen_proportion.GetValue())) *
|
||||
res_scale;
|
||||
height = Core::kScreenTopHeight * res_scale;
|
||||
}
|
||||
if (Settings::values.upright_screen.GetValue()) {
|
||||
std::swap(width, height);
|
||||
}
|
||||
return LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
|
||||
Settings::values.upright_screen.GetValue(),
|
||||
Settings::values.large_screen_proportion.GetValue(),
|
||||
VerticalAlignment::Bottom);
|
||||
|
||||
case Settings::LayoutOption::SideScreen:
|
||||
width = (Core::kScreenTopWidth + Core::kScreenBottomWidth) * res_scale;
|
||||
height = Core::kScreenTopHeight * res_scale;
|
||||
|
||||
if (Settings::values.upright_screen.GetValue()) {
|
||||
std::swap(width, height);
|
||||
}
|
||||
return LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
|
||||
Settings::values.upright_screen.GetValue(), 1,
|
||||
VerticalAlignment::Middle);
|
||||
|
||||
case Settings::LayoutOption::MobilePortrait:
|
||||
width = Core::kScreenTopWidth * res_scale;
|
||||
height = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale;
|
||||
return MobilePortraitFrameLayout(width, height, Settings::values.swap_screen.GetValue());
|
||||
|
||||
case Settings::LayoutOption::MobileLandscape: {
|
||||
constexpr float large_screen_proportion = 2.25f;
|
||||
if (Settings::values.swap_screen.GetValue()) {
|
||||
width = (Core::kScreenBottomWidth +
|
||||
static_cast<int>(Core::kScreenTopWidth / large_screen_proportion)) *
|
||||
res_scale;
|
||||
height = Core::kScreenBottomHeight * res_scale;
|
||||
} else {
|
||||
width = (Core::kScreenTopWidth +
|
||||
static_cast<int>(Core::kScreenBottomWidth / large_screen_proportion)) *
|
||||
res_scale;
|
||||
height = Core::kScreenTopHeight * res_scale;
|
||||
}
|
||||
return LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(), false,
|
||||
large_screen_proportion, VerticalAlignment::Top);
|
||||
}
|
||||
return layout;
|
||||
|
||||
case Settings::LayoutOption::Default:
|
||||
default:
|
||||
width = Core::kScreenTopWidth * res_scale;
|
||||
height = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale;
|
||||
|
||||
if (Settings::values.upright_screen.GetValue()) {
|
||||
std::swap(width, height);
|
||||
}
|
||||
return DefaultFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
|
||||
Settings::values.upright_screen.GetValue());
|
||||
}
|
||||
UNREACHABLE();
|
||||
}
|
||||
|
||||
FramebufferLayout GetCardboardSettings(const FramebufferLayout& layout) {
|
||||
|
@ -20,6 +20,31 @@ enum class DisplayOrientation {
|
||||
PortraitFlipped, // 3DS rotated 270 degrees counter-clockwise
|
||||
};
|
||||
|
||||
/// Describes the vertical alignment of the top and bottom screens in LargeFrameLayout
|
||||
/// Top
|
||||
/// +-------------+-----+
|
||||
/// | | |
|
||||
/// | +-----+
|
||||
/// | |
|
||||
/// +-------------+
|
||||
/// Middle
|
||||
/// +-------------+
|
||||
/// | +-----+
|
||||
/// | | |
|
||||
/// | +-----+
|
||||
/// +-------------+
|
||||
/// Bottom
|
||||
/// +-------------+
|
||||
/// | |
|
||||
/// | +-----+
|
||||
/// | | |
|
||||
/// +-------------+-----+
|
||||
enum class VerticalAlignment {
|
||||
Top,
|
||||
Middle,
|
||||
Bottom,
|
||||
};
|
||||
|
||||
/// Describes the horizontal coordinates for the right eye screen when using Cardboard VR
|
||||
struct CardboardSettings {
|
||||
u32 top_screen_right_eye;
|
||||
@ -43,7 +68,7 @@ struct FramebufferLayout {
|
||||
CardboardSettings cardboard;
|
||||
|
||||
/**
|
||||
* Returns the ration of pixel size of the top screen, compared to the native size of the 3DS
|
||||
* Returns the ratio of pixel size of the top screen, compared to the native size of the 3DS
|
||||
* screen.
|
||||
*/
|
||||
u32 GetScalingRatio() const;
|
||||
@ -54,6 +79,7 @@ struct FramebufferLayout {
|
||||
* @param width Window framebuffer width in pixels
|
||||
* @param height Window framebuffer height in pixels
|
||||
* @param is_swapped if true, the bottom screen will be displayed above the top screen
|
||||
* @param upright if true, the screens will be rotated 90 degrees anti-clockwise
|
||||
* @return Newly created FramebufferLayout object with default screen regions initialized
|
||||
*/
|
||||
FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool is_swapped, bool upright);
|
||||
@ -67,25 +93,12 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool is_swapped, boo
|
||||
*/
|
||||
FramebufferLayout MobilePortraitFrameLayout(u32 width, u32 height, bool is_swapped);
|
||||
|
||||
/**
|
||||
* Factory method for constructing a Frame with the a 4x size Top screen with a 1x size bottom
|
||||
* screen on the right
|
||||
* This is useful in particular because it matches well with a 1920x1080 resolution monitor
|
||||
* @param width Window framebuffer width in pixels
|
||||
* @param height Window framebuffer height in pixels
|
||||
* @param is_swapped if true, the bottom screen will be the large display
|
||||
* @param scale_factor Scale factor to use for bottom screen with respect to top screen
|
||||
* @param center_vertical When true, centers the top and bottom screens vertically
|
||||
* @return Newly created FramebufferLayout object with default screen regions initialized
|
||||
*/
|
||||
FramebufferLayout MobileLandscapeFrameLayout(u32 width, u32 height, bool is_swapped,
|
||||
float scale_factor, bool center_vertical);
|
||||
|
||||
/**
|
||||
* Factory method for constructing a FramebufferLayout with only the top or bottom screen
|
||||
* @param width Window framebuffer width in pixels
|
||||
* @param height Window framebuffer height in pixels
|
||||
* @param is_swapped if true, the bottom screen will be displayed (and the top won't be displayed)
|
||||
* @param upright if true, the screens will be rotated 90 degrees anti-clockwise
|
||||
* @return Newly created FramebufferLayout object with default screen regions initialized
|
||||
*/
|
||||
FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool is_swapped, bool upright);
|
||||
@ -97,32 +110,25 @@ FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool is_swapped, bool
|
||||
* @param width Window framebuffer width in pixels
|
||||
* @param height Window framebuffer height in pixels
|
||||
* @param is_swapped if true, the bottom screen will be the large display
|
||||
* @param upright if true, the screens will be rotated 90 degrees anti-clockwise
|
||||
* @param scale_factor The ratio between the large screen with respect to the smaller screen
|
||||
* @param vertical_alignment The vertical alignment of the smaller screen relative to the larger
|
||||
* screen
|
||||
* @return Newly created FramebufferLayout object with default screen regions initialized
|
||||
*/
|
||||
FramebufferLayout LargeFrameLayout(u32 width, u32 height, bool is_swapped, bool upright,
|
||||
float scale_factor);
|
||||
float scale_factor, VerticalAlignment vertical_alignment);
|
||||
/**
|
||||
* Factory method for constructing a frame with 2.5 times bigger top screen on the right,
|
||||
* and 1x top and bottom screen on the left
|
||||
* @param width Window framebuffer width in pixels
|
||||
* @param height Window framebuffer height in pixels
|
||||
* @param is_swapped if true, the bottom screen will be the large display
|
||||
* @param upright if true, the screens will be rotated 90 degrees anti-clockwise
|
||||
* @return Newly created FramebufferLayout object with default screen regions initialized
|
||||
*/
|
||||
FramebufferLayout HybridScreenLayout(u32 width, u32 height, bool swapped, bool upright);
|
||||
|
||||
/**
|
||||
* Factory method for constructing a Frame with the Top screen and bottom
|
||||
* screen side by side
|
||||
* This is useful for devices with small screens, like the GPDWin
|
||||
* @param width Window framebuffer width in pixels
|
||||
* @param height Window framebuffer height in pixels
|
||||
* @param is_swapped if true, the bottom screen will be the left display
|
||||
* @return Newly created FramebufferLayout object with default screen regions initialized
|
||||
*/
|
||||
FramebufferLayout SideFrameLayout(u32 width, u32 height, bool is_swapped, bool upright);
|
||||
|
||||
/**
|
||||
* Factory method for constructing a Frame with the Top screen and bottom
|
||||
* screen on separate windows
|
||||
|
@ -5,97 +5,16 @@
|
||||
#include <cstddef>
|
||||
#include <memory>
|
||||
#include <type_traits>
|
||||
#include <unordered_map>
|
||||
#include <utility>
|
||||
#include "common/assert.h"
|
||||
#include "common/common_types.h"
|
||||
#include "core/core.h"
|
||||
#include "core/core_timing.h"
|
||||
#include "core/hle/applets/applet.h"
|
||||
#include "core/hle/applets/erreula.h"
|
||||
#include "core/hle/applets/mii_selector.h"
|
||||
#include "core/hle/applets/mint.h"
|
||||
#include "core/hle/applets/swkbd.h"
|
||||
#include "core/hle/result.h"
|
||||
|
||||
namespace HLE::Applets {
|
||||
|
||||
static std::unordered_map<Service::APT::AppletId, std::shared_ptr<Applet>> applets;
|
||||
/// The CoreTiming event identifier for the Applet update callback.
|
||||
static Core::TimingEventType* applet_update_event = nullptr;
|
||||
/// The interval at which the Applet update callback will be called, 16.6ms
|
||||
static const u64 applet_update_interval_us = 16666;
|
||||
|
||||
ResultCode Applet::Create(Service::APT::AppletId id, Service::APT::AppletId parent, bool preload,
|
||||
const std::shared_ptr<Service::APT::AppletManager>& manager) {
|
||||
switch (id) {
|
||||
case Service::APT::AppletId::SoftwareKeyboard1:
|
||||
case Service::APT::AppletId::SoftwareKeyboard2:
|
||||
applets[id] = std::make_shared<SoftwareKeyboard>(id, parent, preload, manager);
|
||||
break;
|
||||
case Service::APT::AppletId::Ed1:
|
||||
case Service::APT::AppletId::Ed2:
|
||||
applets[id] = std::make_shared<MiiSelector>(id, parent, preload, manager);
|
||||
break;
|
||||
case Service::APT::AppletId::Error:
|
||||
case Service::APT::AppletId::Error2:
|
||||
applets[id] = std::make_shared<ErrEula>(id, parent, preload, manager);
|
||||
break;
|
||||
case Service::APT::AppletId::Mint:
|
||||
case Service::APT::AppletId::Mint2:
|
||||
applets[id] = std::make_shared<Mint>(id, parent, preload, manager);
|
||||
break;
|
||||
default:
|
||||
LOG_ERROR(Service_APT, "Could not create applet {}", id);
|
||||
// TODO(Subv): Find the right error code
|
||||
return ResultCode(ErrorDescription::NotFound, ErrorModule::Applet,
|
||||
ErrorSummary::NotSupported, ErrorLevel::Permanent);
|
||||
}
|
||||
|
||||
Service::APT::AppletAttributes attributes;
|
||||
attributes.applet_pos.Assign(Service::APT::AppletPos::AutoLibrary);
|
||||
attributes.is_home_menu.Assign(false);
|
||||
const auto lock_handle_data = manager->GetLockHandle(attributes);
|
||||
|
||||
manager->Initialize(id, lock_handle_data->corrected_attributes);
|
||||
manager->Enable(lock_handle_data->corrected_attributes);
|
||||
if (preload) {
|
||||
manager->FinishPreloadingLibraryApplet(id);
|
||||
}
|
||||
|
||||
// Schedule the update event
|
||||
Core::System::GetInstance().CoreTiming().ScheduleEvent(
|
||||
usToCycles(applet_update_interval_us), applet_update_event, static_cast<u64>(id));
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
std::shared_ptr<Applet> Applet::Get(Service::APT::AppletId id) {
|
||||
auto itr = applets.find(id);
|
||||
if (itr != applets.end())
|
||||
return itr->second;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/// Handles updating the current Applet every time it's called.
|
||||
static void AppletUpdateEvent(u64 applet_id, s64 cycles_late) {
|
||||
const auto id = static_cast<Service::APT::AppletId>(applet_id);
|
||||
const auto applet = Applet::Get(id);
|
||||
ASSERT_MSG(applet != nullptr, "Applet doesn't exist! applet_id={:08X}", id);
|
||||
|
||||
if (applet->IsActive()) {
|
||||
applet->Update();
|
||||
}
|
||||
|
||||
// If the applet is still running after the last update, reschedule the event
|
||||
if (applet->IsRunning()) {
|
||||
Core::System::GetInstance().CoreTiming().ScheduleEvent(
|
||||
usToCycles(applet_update_interval_us) - cycles_late, applet_update_event, applet_id);
|
||||
} else {
|
||||
// Otherwise the applet has terminated, in which case we should clean it up
|
||||
applets[id] = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
bool Applet::IsRunning() const {
|
||||
return is_running;
|
||||
}
|
||||
@ -104,10 +23,10 @@ bool Applet::IsActive() const {
|
||||
return is_active;
|
||||
}
|
||||
|
||||
ResultCode Applet::ReceiveParameter(const Service::APT::MessageParameter& parameter) {
|
||||
Result Applet::ReceiveParameter(const Service::APT::MessageParameter& parameter) {
|
||||
switch (parameter.signal) {
|
||||
case Service::APT::SignalType::Wakeup: {
|
||||
ResultCode result = Start(parameter);
|
||||
Result result = Start(parameter);
|
||||
if (!result.IsError()) {
|
||||
is_active = true;
|
||||
}
|
||||
@ -140,13 +59,4 @@ void Applet::CloseApplet(std::shared_ptr<Kernel::Object> object, const std::vect
|
||||
is_running = false;
|
||||
}
|
||||
|
||||
void Init() {
|
||||
// Register the applet update callback
|
||||
applet_update_event = Core::System::GetInstance().CoreTiming().RegisterEvent(
|
||||
"HLE Applet Update Event", AppletUpdateEvent);
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
Core::System::GetInstance().CoreTiming().RemoveEvent(applet_update_event);
|
||||
}
|
||||
} // namespace HLE::Applets
|
||||
|
@ -14,30 +14,12 @@ class Applet {
|
||||
public:
|
||||
virtual ~Applet() = default;
|
||||
|
||||
/**
|
||||
* Creates an instance of the Applet subclass identified by the parameter.
|
||||
* and stores it in a global map.
|
||||
* @param id Id of the applet to create.
|
||||
* @param parent Id of the applet's parent.
|
||||
* @param preload Whether the applet is being preloaded.
|
||||
* @returns ResultCode Whether the operation was successful or not.
|
||||
*/
|
||||
static ResultCode Create(Service::APT::AppletId id, Service::APT::AppletId parent, bool preload,
|
||||
const std::shared_ptr<Service::APT::AppletManager>& manager);
|
||||
|
||||
/**
|
||||
* Retrieves the Applet instance identified by the specified id.
|
||||
* @param id Id of the Applet to retrieve.
|
||||
* @returns Requested Applet or nullptr if not found.
|
||||
*/
|
||||
static std::shared_ptr<Applet> Get(Service::APT::AppletId id);
|
||||
|
||||
/**
|
||||
* Handles a parameter from the application.
|
||||
* @param parameter Parameter data to handle.
|
||||
* @returns ResultCode Whether the operation was successful or not.
|
||||
* @returns Result Whether the operation was successful or not.
|
||||
*/
|
||||
ResultCode ReceiveParameter(const Service::APT::MessageParameter& parameter);
|
||||
Result ReceiveParameter(const Service::APT::MessageParameter& parameter);
|
||||
|
||||
/**
|
||||
* Whether the applet is currently running.
|
||||
@ -55,29 +37,31 @@ public:
|
||||
virtual void Update() = 0;
|
||||
|
||||
protected:
|
||||
Applet(Service::APT::AppletId id, Service::APT::AppletId parent, bool preload,
|
||||
std::weak_ptr<Service::APT::AppletManager> manager)
|
||||
: id(id), parent(parent), preload(preload), manager(std::move(manager)) {}
|
||||
Applet(Core::System& system, Service::APT::AppletId id, Service::APT::AppletId parent,
|
||||
bool preload, std::weak_ptr<Service::APT::AppletManager> manager)
|
||||
: system(system), id(id), parent(parent), preload(preload), manager(std::move(manager)) {}
|
||||
|
||||
/**
|
||||
* Handles a parameter from the application.
|
||||
* @param parameter Parameter data to handle.
|
||||
* @returns ResultCode Whether the operation was successful or not.
|
||||
* @returns Result Whether the operation was successful or not.
|
||||
*/
|
||||
virtual ResultCode ReceiveParameterImpl(const Service::APT::MessageParameter& parameter) = 0;
|
||||
virtual Result ReceiveParameterImpl(const Service::APT::MessageParameter& parameter) = 0;
|
||||
|
||||
/**
|
||||
* Handles the Applet start event, triggered from the application.
|
||||
* @param parameter Parameter data to handle.
|
||||
* @returns ResultCode Whether the operation was successful or not.
|
||||
* @returns Result Whether the operation was successful or not.
|
||||
*/
|
||||
virtual ResultCode Start(const Service::APT::MessageParameter& parameter) = 0;
|
||||
virtual Result Start(const Service::APT::MessageParameter& parameter) = 0;
|
||||
|
||||
/**
|
||||
* Sends the LibAppletClosing signal to the application,
|
||||
* along with the relevant data buffers.
|
||||
*/
|
||||
virtual ResultCode Finalize() = 0;
|
||||
virtual Result Finalize() = 0;
|
||||
|
||||
Core::System& system;
|
||||
|
||||
Service::APT::AppletId id; ///< Id of this Applet
|
||||
Service::APT::AppletId parent; ///< Id of this Applet's parent
|
||||
@ -97,9 +81,4 @@ private:
|
||||
std::weak_ptr<Service::APT::AppletManager> manager;
|
||||
};
|
||||
|
||||
/// Initializes the HLE applets
|
||||
void Init();
|
||||
|
||||
/// Shuts down the HLE applets
|
||||
void Shutdown();
|
||||
} // namespace HLE::Applets
|
||||
|
@ -9,12 +9,12 @@
|
||||
|
||||
namespace HLE::Applets {
|
||||
|
||||
ResultCode ErrEula::ReceiveParameterImpl(const Service::APT::MessageParameter& parameter) {
|
||||
Result ErrEula::ReceiveParameterImpl(const Service::APT::MessageParameter& parameter) {
|
||||
if (parameter.signal != Service::APT::SignalType::Request) {
|
||||
LOG_ERROR(Service_APT, "unsupported signal {}", parameter.signal);
|
||||
UNIMPLEMENTED();
|
||||
// TODO(Subv): Find the right error code
|
||||
return ResultCode(-1);
|
||||
return ResultUnknown;
|
||||
}
|
||||
|
||||
// The LibAppJustStarted message contains a buffer with the size of the framebuffer shared
|
||||
@ -28,7 +28,7 @@ ResultCode ErrEula::ReceiveParameterImpl(const Service::APT::MessageParameter& p
|
||||
// TODO: allocated memory never released
|
||||
using Kernel::MemoryPermission;
|
||||
// Create a SharedMemory that directly points to this heap block.
|
||||
framebuffer_memory = Core::System::GetInstance().Kernel().CreateSharedMemoryForApplet(
|
||||
framebuffer_memory = system.Kernel().CreateSharedMemoryForApplet(
|
||||
0, capture_info.size, MemoryPermission::ReadWrite, MemoryPermission::ReadWrite,
|
||||
"ErrEula Memory");
|
||||
|
||||
@ -40,10 +40,10 @@ ResultCode ErrEula::ReceiveParameterImpl(const Service::APT::MessageParameter& p
|
||||
.object = framebuffer_memory,
|
||||
});
|
||||
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
ResultCode ErrEula::Start(const Service::APT::MessageParameter& parameter) {
|
||||
Result ErrEula::Start(const Service::APT::MessageParameter& parameter) {
|
||||
startup_param = parameter.buffer;
|
||||
|
||||
// TODO(Subv): Set the expected fields in the response buffer before resending it to the
|
||||
@ -52,14 +52,14 @@ ResultCode ErrEula::Start(const Service::APT::MessageParameter& parameter) {
|
||||
|
||||
// Let the application know that we're closing.
|
||||
Finalize();
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
ResultCode ErrEula::Finalize() {
|
||||
Result ErrEula::Finalize() {
|
||||
std::vector<u8> buffer(startup_param.size());
|
||||
std::fill(buffer.begin(), buffer.end(), 0);
|
||||
CloseApplet(nullptr, buffer);
|
||||
return RESULT_SUCCESS;
|
||||
return ResultSuccess;
|
||||
}
|
||||
|
||||
void ErrEula::Update() {}
|
||||
|
@ -11,13 +11,13 @@ namespace HLE::Applets {
|
||||
|
||||
class ErrEula final : public Applet {
|
||||
public:
|
||||
explicit ErrEula(Service::APT::AppletId id, Service::APT::AppletId parent, bool preload,
|
||||
std::weak_ptr<Service::APT::AppletManager> manager)
|
||||
: Applet(id, parent, preload, std::move(manager)) {}
|
||||
explicit ErrEula(Core::System& system, Service::APT::AppletId id, Service::APT::AppletId parent,
|
||||
bool preload, std::weak_ptr<Service::APT::AppletManager> manager)
|
||||
: Applet(system, id, parent, preload, std::move(manager)) {}
|
||||
|
||||
ResultCode ReceiveParameterImpl(const Service::APT::MessageParameter& parameter) override;
|
||||
ResultCode Start(const Service::APT::MessageParameter& parameter) override;
|
||||
ResultCode Finalize() override;
|
||||
Result ReceiveParameterImpl(const Service::APT::MessageParameter& parameter) override;
|
||||
Result Start(const Service::APT::MessageParameter& parameter) override;
|
||||
Result Finalize() override;
|
||||
void Update() override;
|
||||
|
||||
private:
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user