catto
/
shadPS4
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'shadps4-emu:main' into main

This commit is contained in:
menaman123 2024-08-09 19:43:02 -04:00 committed by GitHub
parent 153362f13e ea4ae56f4d
commit 8b9843c1ec
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 101 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
externals/fmt vendored

@ -1 +1 @@
Subproject commit bc8d32e9643d2be5fc070abf2a50bc021544545d Subproject commit c98518351efd5a46f5d448e947e0b7242d197d07

2
externals/glslang vendored

@ -1 +1 @@
Subproject commit 52f68dc6b2a9d017b43161f31f13a6f44636ee7c Subproject commit 7c4d91e7819a1d27213aa3499953d54ae1a00e8f

2
externals/magic_enum vendored

@ -1 +1 @@
Subproject commit 664ee62c12570948b0e025d15b42d641fba8d54a Subproject commit dae6bbf16c363e9ead4e628a47fdb02956a634f3

2
externals/sdl3 vendored

@ -1 +1 @@
Subproject commit f9a06c20ed85fb1d6754fc2280d6183382217910 Subproject commit 4cc3410dce50cefce98d3cf3cf1bc8eca83b862a

2
externals/toml11 vendored

@ -1 +1 @@
Subproject commit b389bbc4ebf90fa2fe7651de3046fb19f661ba3c Subproject commit fcb1d3d7e5885edfadbbe9572991dc4b3248af58

2
externals/vulkan-headers vendored

@ -1 +1 @@
Subproject commit b379292b2ab6df5771ba9870d53cf8b2c9295daf Subproject commit 595c8d4794410a4e64b98dc58d27c0310d7ea2fd

2
externals/xxhash vendored

@ -1 +1 @@
Subproject commit a57f6cce2698049863af8c25787084ae0489d849 Subproject commit ee65ff988bab34a184c700e2fbe1e1c5bc27485d

111
src/common/config.cpp
View File

@ -43,6 +43,8 @@ u32 m_window_size_H = 720;
std::vector<std::string> m_pkg_viewer; std::vector<std::string> m_pkg_viewer;
std::vector<std::string> m_elf_viewer; std::vector<std::string> m_elf_viewer;
std::vector<std::string> m_recent_files; std::vector<std::string> m_recent_files;
// Settings
u32 m_language = 1; // english
bool isLleLibc() { bool isLleLibc() {
return isLibc; return isLibc;
@ -207,6 +209,9 @@ std::vector<std::string> getRecentFiles() {
return m_recent_files; return m_recent_files;
} }
u32 GetLanguage() {
return m_language;
}
void load(const std::filesystem::path& path) { void load(const std::filesystem::path& path) {
// If the configuration file does not exist, create it and return // If the configuration file does not exist, create it and return
std::error_code error; std::error_code error;
@ -223,90 +228,82 @@ void load(const std::filesystem::path& path) {
fmt::print("Got exception trying to load config file. Exception: {}\n", ex.what()); fmt::print("Got exception trying to load config file. Exception: {}\n", ex.what());
return; return;
} }
if (data.contains("General")) { if (data.contains("General")) {
auto generalResult = toml::expect<toml::value>(data.at("General")); const toml::value& general = data.at("General");
if (generalResult.is_ok()) {
auto general = generalResult.unwrap();
isNeo = toml::find_or<toml::boolean>(general, "isPS4Pro", false); isNeo = toml::find_or<bool>(general, "isPS4Pro", false);
isFullscreen = toml::find_or<toml::boolean>(general, "Fullscreen", false); isFullscreen = toml::find_or<bool>(general, "Fullscreen", false);
logFilter = toml::find_or<toml::string>(general, "logFilter", ""); logFilter = toml::find_or<std::string>(general, "logFilter", "");
logType = toml::find_or<toml::string>(general, "logType", "sync"); logType = toml::find_or<std::string>(general, "logType", "sync");
isShowSplash = toml::find_or<toml::boolean>(general, "showSplash", true); isShowSplash = toml::find_or<bool>(general, "showSplash", true);
}
} }
if (data.contains("GPU")) { if (data.contains("GPU")) {
auto gpuResult = toml::expect<toml::value>(data.at("GPU")); const toml::value& gpu = data.at("GPU");
if (gpuResult.is_ok()) {
auto gpu = gpuResult.unwrap();
screenWidth = toml::find_or<toml::integer>(gpu, "screenWidth", screenWidth); screenWidth = toml::find_or<int>(gpu, "screenWidth", screenWidth);
screenHeight = toml::find_or<toml::integer>(gpu, "screenHeight", screenHeight); screenHeight = toml::find_or<int>(gpu, "screenHeight", screenHeight);
isNullGpu = toml::find_or<toml::boolean>(gpu, "nullGpu", false); isNullGpu = toml::find_or<bool>(gpu, "nullGpu", false);
shouldDumpShaders = toml::find_or<toml::boolean>(gpu, "dumpShaders", false); shouldDumpShaders = toml::find_or<bool>(gpu, "dumpShaders", false);
shouldDumpPM4 = toml::find_or<toml::boolean>(gpu, "dumpPM4", false); shouldDumpPM4 = toml::find_or<bool>(gpu, "dumpPM4", false);
vblankDivider = toml::find_or<toml::integer>(gpu, "vblankDivider", 1); vblankDivider = toml::find_or<int>(gpu, "vblankDivider", 1);
}
} }
if (data.contains("Vulkan")) { if (data.contains("Vulkan")) {
const auto vkResult = toml::expect<toml::value>(data.at("Vulkan")); const toml::value& vk = data.at("Vulkan");
if (vkResult.is_ok()) {
auto vk = vkResult.unwrap();
gpuId = toml::find_or<toml::integer>(vk, "gpuId", 0); gpuId = toml::find_or<int>(vk, "gpuId", -1);
vkValidation = toml::find_or<toml::boolean>(vk, "validation", true); vkValidation = toml::find_or<bool>(vk, "validation", false);
vkValidationSync = toml::find_or<toml::boolean>(vk, "validation_sync", true); vkValidationSync = toml::find_or<bool>(vk, "validation_sync", false);
rdocEnable = toml::find_or<toml::boolean>(vk, "rdocEnable", false); rdocEnable = toml::find_or<bool>(vk, "rdocEnable", false);
}
} }
if (data.contains("Debug")) { if (data.contains("Debug")) {
auto debugResult = toml::expect<toml::value>(data.at("Debug")); const toml::value& debug = data.at("Debug");
if (debugResult.is_ok()) {
auto debug = debugResult.unwrap();
isDebugDump = toml::find_or<toml::boolean>(debug, "DebugDump", false); isDebugDump = toml::find_or<bool>(debug, "DebugDump", false);
}
} }
if (data.contains("LLE")) { if (data.contains("LLE")) {
auto lleResult = toml::expect<toml::value>(data.at("LLE")); const toml::value& lle = data.at("LLE");
if (lleResult.is_ok()) {
auto lle = lleResult.unwrap();
isLibc = toml::find_or<toml::boolean>(lle, "libc", true); isLibc = toml::find_or<bool>(lle, "libc", true);
}
} }
if (data.contains("GUI")) { if (data.contains("GUI")) {
auto guiResult = toml::expect<toml::value>(data.at("GUI")); const toml::value& gui = data.at("GUI");
if (guiResult.is_ok()) {
auto gui = guiResult.unwrap();
m_icon_size = toml::find_or<toml::integer>(gui, "iconSize", 0); m_icon_size = toml::find_or<int>(gui, "iconSize", 0);
m_icon_size_grid = toml::find_or<toml::integer>(gui, "iconSizeGrid", 0); m_icon_size_grid = toml::find_or<int>(gui, "iconSizeGrid", 0);
m_slider_pos = toml::find_or<toml::integer>(gui, "sliderPos", 0); m_slider_pos = toml::find_or<int>(gui, "sliderPos", 0);
m_slider_pos_grid = toml::find_or<toml::integer>(gui, "sliderPosGrid", 0); m_slider_pos_grid = toml::find_or<int>(gui, "sliderPosGrid", 0);
mw_themes = toml::find_or<toml::integer>(gui, "theme", 0); mw_themes = toml::find_or<int>(gui, "theme", 0);
m_window_size_W = toml::find_or<toml::integer>(gui, "mw_width", 0); m_window_size_W = toml::find_or<int>(gui, "mw_width", 0);
m_window_size_H = toml::find_or<toml::integer>(gui, "mw_height", 0); m_window_size_H = toml::find_or<int>(gui, "mw_height", 0);
settings_install_dir = toml::find_or<toml::string>(gui, "installDir", ""); settings_install_dir = toml::find_or<std::string>(gui, "installDir", "");
main_window_geometry_x = toml::find_or<toml::integer>(gui, "geometry_x", 0); main_window_geometry_x = toml::find_or<int>(gui, "geometry_x", 0);
main_window_geometry_y = toml::find_or<toml::integer>(gui, "geometry_y", 0); main_window_geometry_y = toml::find_or<int>(gui, "geometry_y", 0);
main_window_geometry_w = toml::find_or<toml::integer>(gui, "geometry_w", 0); main_window_geometry_w = toml::find_or<int>(gui, "geometry_w", 0);
main_window_geometry_h = toml::find_or<toml::integer>(gui, "geometry_h", 0); main_window_geometry_h = toml::find_or<int>(gui, "geometry_h", 0);
m_pkg_viewer = toml::find_or<std::vector<std::string>>(gui, "pkgDirs", {}); m_pkg_viewer = toml::find_or<std::vector<std::string>>(gui, "pkgDirs", {});
m_elf_viewer = toml::find_or<std::vector<std::string>>(gui, "elfDirs", {}); m_elf_viewer = toml::find_or<std::vector<std::string>>(gui, "elfDirs", {});
m_recent_files = toml::find_or<std::vector<std::string>>(gui, "recentFiles", {}); m_recent_files = toml::find_or<std::vector<std::string>>(gui, "recentFiles", {});
m_table_mode = toml::find_or<toml::integer>(gui, "gameTableMode", 0); m_table_mode = toml::find_or<int>(gui, "gameTableMode", 0);
} }
if (data.contains("Settings")) {
const toml::value& settings = data.at("Settings");
m_language = toml::find_or<int>(settings, "consoleLanguage", 1);
} }
} }
void save(const std::filesystem::path& path) { void save(const std::filesystem::path& path) {
toml::basic_value<toml::preserve_comments> data; toml::value data;
std::error_code error; std::error_code error;
if (std::filesystem::exists(path, error)) { if (std::filesystem::exists(path, error)) {
try { try {
data = toml::parse<toml::preserve_comments>(path); data = toml::parse(path);
} catch (const std::exception& ex) { } catch (const std::exception& ex) {
fmt::print("Exception trying to parse config file. Exception: {}\n", ex.what()); fmt::print("Exception trying to parse config file. Exception: {}\n", ex.what());
return; return;
@ -353,6 +350,8 @@ void save(const std::filesystem::path& path) {
data["GUI"]["elfDirs"] = m_elf_viewer; data["GUI"]["elfDirs"] = m_elf_viewer;
data["GUI"]["recentFiles"] = m_recent_files; data["GUI"]["recentFiles"] = m_recent_files;
data["Settings"]["consoleLanguage"] = m_language;
std::ofstream file(path, std::ios::out); std::ofstream file(path, std::ios::out);
file << data; file << data;
file.close(); file.close();

3
src/common/config.h
View File

@ -64,4 +64,7 @@ std::vector<std::string> getPkgViewer();
std::vector<std::string> getElfViewer(); std::vector<std::string> getElfViewer();
std::vector<std::string> getRecentFiles(); std::vector<std::string> getRecentFiles();
// settings
u32 GetLanguage();
}; // namespace Config }; // namespace Config

2
src/core/libraries/kernel/thread_management.cpp
View File

@ -1519,6 +1519,8 @@ void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
LIB_FUNCTION("1tKyG7RlMJo", "libkernel", 1, "libkernel", 1, 1, scePthreadGetprio); LIB_FUNCTION("1tKyG7RlMJo", "libkernel", 1, "libkernel", 1, 1, scePthreadGetprio);
LIB_FUNCTION("W0Hpm2X0uPE", "libkernel", 1, "libkernel", 1, 1, scePthreadSetprio); LIB_FUNCTION("W0Hpm2X0uPE", "libkernel", 1, "libkernel", 1, 1, scePthreadSetprio);
LIB_FUNCTION("GBUY7ywdULE", "libkernel", 1, "libkernel", 1, 1, scePthreadRename); LIB_FUNCTION("GBUY7ywdULE", "libkernel", 1, "libkernel", 1, 1, scePthreadRename);
LIB_FUNCTION("F+yfmduIBB8", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetstackaddr);
LIB_FUNCTION("El+cQ20DynU", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetguardsize);
LIB_FUNCTION("aI+OeCz8xrQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSelf); LIB_FUNCTION("aI+OeCz8xrQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSelf);
LIB_FUNCTION("EotR8a3ASf4", "libkernel", 1, "libkernel", 1, 1, posix_pthread_self); LIB_FUNCTION("EotR8a3ASf4", "libkernel", 1, "libkernel", 1, 1, posix_pthread_self);

19
src/core/libraries/pad/pad.cpp
View File

@ -2,6 +2,7 @@
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
// Generated By moduleGenerator // Generated By moduleGenerator
#include <common/assert.h>
#include <common/singleton.h> #include <common/singleton.h>
#include "common/logging/log.h" #include "common/logging/log.h"
#include "core/libraries/error_codes.h" #include "core/libraries/error_codes.h"
@ -85,7 +86,18 @@ int PS4_SYSV_ABI scePadGetCapability() {
int PS4_SYSV_ABI scePadGetControllerInformation(s32 handle, OrbisPadControllerInformation* pInfo) { int PS4_SYSV_ABI scePadGetControllerInformation(s32 handle, OrbisPadControllerInformation* pInfo) {
LOG_INFO(Lib_Pad, "called handle = {}", handle); LOG_INFO(Lib_Pad, "called handle = {}", handle);
std::memset(pInfo, 0, sizeof(OrbisPadControllerInformation)); if (handle < 0) {
pInfo->touchPadInfo.pixelDensity = 1;
pInfo->touchPadInfo.resolution.x = 1920;
pInfo->touchPadInfo.resolution.y = 950;
pInfo->stickInfo.deadZoneLeft = 2;
pInfo->stickInfo.deadZoneRight = 2;
pInfo->connectionType = ORBIS_PAD_PORT_TYPE_STANDARD;
pInfo->connectedCount = 1;
pInfo->connected = false;
pInfo->deviceClass = ORBIS_PAD_DEVICE_CLASS_STANDARD;
return SCE_OK;
}
pInfo->touchPadInfo.pixelDensity = 1; pInfo->touchPadInfo.pixelDensity = 1;
pInfo->touchPadInfo.resolution.x = 1920; pInfo->touchPadInfo.resolution.x = 1920;
pInfo->touchPadInfo.resolution.y = 950; pInfo->touchPadInfo.resolution.y = 950;
@ -239,7 +251,6 @@ int PS4_SYSV_ABI scePadOutputReport() {
} }
int PS4_SYSV_ABI scePadRead(s32 handle, OrbisPadData* pData, s32 num) { int PS4_SYSV_ABI scePadRead(s32 handle, OrbisPadData* pData, s32 num) {
std::memset(pData, 0, sizeof(OrbisPadData));
int connected_count = 0; int connected_count = 0;
bool connected = false; bool connected = false;
Input::State states[64]; Input::State states[64];
@ -306,11 +317,9 @@ int PS4_SYSV_ABI scePadReadHistory() {
int PS4_SYSV_ABI scePadReadState(s32 handle, OrbisPadData* pData) { int PS4_SYSV_ABI scePadReadState(s32 handle, OrbisPadData* pData) {
auto* controller = Common::Singleton<Input::GameController>::Instance(); auto* controller = Common::Singleton<Input::GameController>::Instance();
int connectedCount = 0; int connectedCount = 0;
bool isConnected = false; bool isConnected = false;
Input::State state; Input::State state;
std::memset(pData, 0, sizeof(OrbisPadData));
controller->ReadState(&state, &isConnected, &connectedCount); controller->ReadState(&state, &isConnected, &connectedCount);
pData->buttons = state.buttonsState; pData->buttons = state.buttonsState;
pData->leftStick.x = state.axes[static_cast<int>(Input::Axis::LeftX)]; pData->leftStick.x = state.axes[static_cast<int>(Input::Axis::LeftX)];
@ -322,7 +331,7 @@ int PS4_SYSV_ABI scePadReadState(s32 handle, OrbisPadData* pData) {
pData->orientation.x = 0; pData->orientation.x = 0;
pData->orientation.y = 0; pData->orientation.y = 0;
pData->orientation.z = 0; pData->orientation.z = 0;
pData->orientation.w = 0; pData->orientation.w = 1;
pData->acceleration.x = 0.0f; pData->acceleration.x = 0.0f;
pData->acceleration.y = 0.0f; pData->acceleration.y = 0.0f;
pData->acceleration.z = 0.0f; pData->acceleration.z = 0.0f;

6
src/core/libraries/playgo/playgo.cpp
View File

@ -58,6 +58,7 @@ s32 PS4_SYSV_ABI scePlayGoGetLocus(OrbisPlayGoHandle handle, const OrbisPlayGoCh
if (chunkIds[i] <= playgo->GetPlaygoHeader().mchunk_count) { if (chunkIds[i] <= playgo->GetPlaygoHeader().mchunk_count) {
outLoci[i] = OrbisPlayGoLocusValue::ORBIS_PLAYGO_LOCUS_LOCAL_FAST; outLoci[i] = OrbisPlayGoLocusValue::ORBIS_PLAYGO_LOCUS_LOCAL_FAST;
} else { } else {
outLoci[i] = ORBIS_PLAYGO_LOCUS_NOT_DOWNLOADED;
return ORBIS_PLAYGO_ERROR_BAD_CHUNK_ID; return ORBIS_PLAYGO_ERROR_BAD_CHUNK_ID;
} }
} }
@ -70,12 +71,13 @@ s32 PS4_SYSV_ABI scePlayGoGetProgress(OrbisPlayGoHandle handle, const OrbisPlayG
handle, *chunkIds, numberOfEntries); handle, *chunkIds, numberOfEntries);
outProgress->progressSize = 0x10000; // todo? outProgress->progressSize = 0x10000; // todo?
outProgress->totalSize = 0x10000; outProgress->totalSize = 0x10000;
return 0; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI scePlayGoGetToDoList(OrbisPlayGoHandle handle, OrbisPlayGoToDo* outTodoList, s32 PS4_SYSV_ABI scePlayGoGetToDoList(OrbisPlayGoHandle handle, OrbisPlayGoToDo* outTodoList,
u32 numberOfEntries, u32* outEntries) { u32 numberOfEntries, u32* outEntries) {
LOG_ERROR(Lib_PlayGo, "(STUBBED)called"); LOG_ERROR(Lib_PlayGo, "(STUBBED)called handle = {} numberOfEntries = {}", handle,
numberOfEntries);
if (handle != 1) if (handle != 1)
return ORBIS_PLAYGO_ERROR_BAD_HANDLE; return ORBIS_PLAYGO_ERROR_BAD_HANDLE;
if (outTodoList == nullptr) if (outTodoList == nullptr)

2
src/core/libraries/system/systemservice.cpp
View File

@ -1898,7 +1898,7 @@ s32 PS4_SYSV_ABI sceSystemServiceParamGetInt(int param_id, int* value) {
} }
switch (param_id) { switch (param_id) {
case ORBIS_SYSTEM_SERVICE_PARAM_ID_LANG: case ORBIS_SYSTEM_SERVICE_PARAM_ID_LANG:
*value = ORBIS_SYSTEM_PARAM_LANG_ENGLISH_US; *value = Config::GetLanguage();
break; break;
case ORBIS_SYSTEM_SERVICE_PARAM_ID_DATE_FORMAT: case ORBIS_SYSTEM_SERVICE_PARAM_ID_DATE_FORMAT:
*value = ORBIS_SYSTEM_PARAM_DATE_FORMAT_DDMMYYYY; *value = ORBIS_SYSTEM_PARAM_DATE_FORMAT_DDMMYYYY;

6
src/emulator.cpp
View File

@ -128,6 +128,7 @@ void Emulator::Run(const std::filesystem::path& file) {
std::filesystem::create_directory(mount_temp_dir); std::filesystem::create_directory(mount_temp_dir);
} }
mnt->Mount(mount_temp_dir, "/temp0"); // called in app_content ==> stat/mkdir mnt->Mount(mount_temp_dir, "/temp0"); // called in app_content ==> stat/mkdir
mnt->Mount(mount_temp_dir, "/temp");
const auto& mount_download_dir = const auto& mount_download_dir =
Common::FS::GetUserPath(Common::FS::PathType::DownloadDir) / id; Common::FS::GetUserPath(Common::FS::PathType::DownloadDir) / id;
@ -182,7 +183,7 @@ void Emulator::Run(const std::filesystem::path& file) {
} }
void Emulator::LoadSystemModules(const std::filesystem::path& file) { void Emulator::LoadSystemModules(const std::filesystem::path& file) {
constexpr std::array<SysModules, 10> ModulesToLoad{ constexpr std::array<SysModules, 9> ModulesToLoad{
{{"libSceNgs2.sprx", nullptr}, {{"libSceNgs2.sprx", nullptr},
{"libSceFiber.sprx", nullptr}, {"libSceFiber.sprx", nullptr},
{"libSceUlt.sprx", nullptr}, {"libSceUlt.sprx", nullptr},
@ -191,8 +192,7 @@ void Emulator::LoadSystemModules(const std::filesystem::path& file) {
{"libSceLibcInternal.sprx", &Libraries::LibcInternal::RegisterlibSceLibcInternal}, {"libSceLibcInternal.sprx", &Libraries::LibcInternal::RegisterlibSceLibcInternal},
{"libSceDiscMap.sprx", &Libraries::DiscMap::RegisterlibSceDiscMap}, {"libSceDiscMap.sprx", &Libraries::DiscMap::RegisterlibSceDiscMap},
{"libSceRtc.sprx", &Libraries::Rtc::RegisterlibSceRtc}, {"libSceRtc.sprx", &Libraries::Rtc::RegisterlibSceRtc},
{"libSceJpegEnc.sprx", nullptr}, {"libSceJpegEnc.sprx", nullptr}},
{"libSceJson2.sprx", nullptr}},
}; };
std::vector<std::filesystem::path> found_modules; std::vector<std::filesystem::path> found_modules;

14
src/sdl_window.cpp
View File

@ -45,21 +45,21 @@ WindowSDL::WindowSDL(s32 width_, s32 height_, Input::GameController* controller_
#if defined(SDL_PLATFORM_WIN32) #if defined(SDL_PLATFORM_WIN32)
window_info.type = WindowSystemType::Windows; window_info.type = WindowSystemType::Windows;
window_info.render_surface = window_info.render_surface = SDL_GetPointerProperty(SDL_GetWindowProperties(window),
SDL_GetProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL); SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
#elif defined(SDL_PLATFORM_LINUX) #elif defined(SDL_PLATFORM_LINUX)
if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "x11") == 0) { if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "x11") == 0) {
window_info.type = WindowSystemType::X11; window_info.type = WindowSystemType::X11;
window_info.display_connection = SDL_GetProperty(SDL_GetWindowProperties(window), window_info.display_connection = SDL_GetPointerProperty(
SDL_PROP_WINDOW_X11_DISPLAY_POINTER, NULL); SDL_GetWindowProperties(window), SDL_PROP_WINDOW_X11_DISPLAY_POINTER, NULL);
window_info.render_surface = (void*)SDL_GetNumberProperty( window_info.render_surface = (void*)SDL_GetNumberProperty(
SDL_GetWindowProperties(window), SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0); SDL_GetWindowProperties(window), SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0);
} else if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "wayland") == 0) { } else if (SDL_strcmp(SDL_GetCurrentVideoDriver(), "wayland") == 0) {
window_info.type = WindowSystemType::Wayland; window_info.type = WindowSystemType::Wayland;
window_info.display_connection = SDL_GetProperty( window_info.display_connection = SDL_GetPointerProperty(
SDL_GetWindowProperties(window), SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER, NULL); SDL_GetWindowProperties(window), SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER, NULL);
window_info.render_surface = SDL_GetProperty(SDL_GetWindowProperties(window), window_info.render_surface = SDL_GetPointerProperty(
SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER, NULL); SDL_GetWindowProperties(window), SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER, NULL);
} }
#elif defined(SDL_PLATFORM_MACOS) #elif defined(SDL_PLATFORM_MACOS)
window_info.type = WindowSystemType::Metal; window_info.type = WindowSystemType::Metal;