external: update all dependencies

Author: xerpi

external/CMakeLists.txt

@@ -1,3 +1,11 @@
+# Use Vita3K's glslang (installed glslang doesn't contain SpvBuilder.h, etc)
+set(ENABLE_HLSL OFF CACHE BOOL "" FORCE)
+set(ENABLE_GLSLANG_BINARIES OFF CACHE BOOL "" FORCE)
+set(ENABLE_SPVREMAPPER OFF CACHE BOOL "" FORCE)
+set(ENABLE_OPT OFF CACHE BOOL "" FORCE)
+set(GLSLANG_TESTS OFF CACHE BOOL "" FORCE)
+add_subdirectory(Vita3K/external/glslang)
+
 # Shim libraries for Vita3K
 add_library(vita3k_shim INTERFACE)
 target_include_directories(vita3k_shim INTERFACE ${PROJECT_SOURCE_DIR}/include/vita3k)
@@ -14,7 +22,7 @@ target_include_directories(features INTERFACE Vita3K/vita3k/features/include)
 add_subdirectory(Vita3K/vita3k/gxm)
 target_link_libraries(gxm INTERFACE vita3k_shim)
 target_include_directories(gxm PRIVATE
-${PROJECT_SOURCE_DIR}/include/vita3k
+    ${PROJECT_SOURCE_DIR}/include/vita3k
 )
 
 # Vita3K shader

external/Vita3K

@@ -18,6 +18,10 @@
 #pragma once
 
 #include <filesystem>
+#include <fstream>
+#include <sstream>
+
+#include "string_utils.h"
 
 namespace fs = std::filesystem;
 
@@ -69,8 +73,8 @@ namespace fs_utils
  * \param  extension   The extension of the file (optional)
  * \return A complete Boost.Filesystem file path normalized.
  */
-inline fs::path construct_file_name(const fs::path &base_path, const fs::path &folder_path,
-                                    const fs::path &file_name, const fs::path &extension = "")
+static inline fs::path construct_file_name(const fs::path &base_path, const fs::path &folder_path,
+                                           const fs::path &file_name, const fs::path &extension)
 {
     fs::path full_file_path{ base_path / folder_path / file_name };
     if (!extension.empty())
@@ -79,4 +83,76 @@ inline fs::path construct_file_name(const fs::path &base_path, const fs::path &f
     return full_file_path;
 }
 
+static inline std::string path_to_utf8(const fs::path &path)
+{
+    if constexpr (sizeof(fs::path::value_type) == sizeof(wchar_t)) {
+        return string_utils::wide_to_utf(path.wstring());
+    } else {
+        return path.string();
+    }
+}
+
+static inline fs::path utf8_to_path(const std::string &str)
+{
+    if constexpr (sizeof(fs::path::value_type) == sizeof(wchar_t)) {
+        return fs::path{ string_utils::utf_to_wide(str) };
+    } else {
+        return fs::path{ str };
+    }
+}
+
+static inline fs::path path_concat(const fs::path &path1, const fs::path &path2)
+{
+    return fs::path{ path1.native() + path2.native() };
+}
+
+static inline void dump_data(const fs::path &path, const void *data, const std::streamsize size)
+{
+    std::ofstream of{ path, std::ofstream::binary };
+    if (!of.fail()) {
+        of.write(static_cast<const char *>(data), size);
+        of.close();
+    }
+}
+
+template <typename T> static inline bool read_data(const fs::path &path, std::vector<T> &data)
+{
+    data.clear();
+    std::ifstream file(path, std::ios::binary | std::ios::ate);
+    if (!file.is_open()) {
+        return false;
+    }
+
+    // Get the size of the file
+    std::streamsize size = file.tellg();
+    if (size <= 0) {
+        return false;
+    }
+
+    // Resize the vector to fit the file content
+    data.resize(size);
+
+    // Go back to the beginning of the file and read the content
+    file.seekg(0, std::ios::beg);
+    if (!file.read(reinterpret_cast<char *>(data.data()), size)) {
+        return false;
+    }
+    return true;
+}
+
+static inline bool read_data(const fs::path &path, std::vector<uint8_t> &data)
+{
+    return read_data<uint8_t>(path, data);
+}
+
+static inline bool read_data(const fs::path &path, std::vector<int8_t> &data)
+{
+    return read_data<int8_t>(path, data);
+}
+
+static inline bool read_data(const fs::path &path, std::vector<char> &data)
+{
+    return read_data<char>(path, data);
+}
+
 } // namespace fs_utils

external/mlib

@@ -46,6 +46,9 @@ template <typename... Args> void LOG_CRITICAL(std::string_view fmt, Args &&...ar
     log_print(fmt::format(fmt::runtime(fmt), std::forward<Args>(args)...).c_str());
 }
 
+#undef LOG_INFO_ONCE
+#define LOG_INFO_ONCE LOG_INFO
+
 template <typename T> std::string log_hex(T val)
 {
     using unsigned_type = typename std::make_unsigned<T>::type;

external/vita-headers

@@ -0,0 +1,169 @@
+// Vita3K emulator project
+// Copyright (C) 2025 Vita3K team
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+#pragma once
+
+#include <algorithm>
+#include <codecvt>
+#include <cstdint>
+#include <locale>
+#include <sstream>
+#include <string>
+#include <util/log.h>
+#include <util/string_utils.h>
+#include <vector>
+
+namespace string_utils
+{
+
+std::vector<std::string> split_string(const std::string &str, char delimiter)
+{
+    std::istringstream str_stream(str);
+    std::string segment;
+    std::vector<std::string> seglist;
+
+    const size_t num_segments =
+        std::count_if(str.begin(), str.end(), [&](char c) { return c == delimiter; }) +
+        (str.empty() ? 1 : 0);
+
+    seglist.reserve(num_segments);
+
+    while (std::getline(str_stream, segment, delimiter)) {
+        seglist.push_back(segment);
+    }
+    return seglist;
+}
+
+std::wstring utf_to_wide(const std::string &str)
+{
+    std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
+    return myconv.from_bytes(str);
+}
+
+std::string wide_to_utf(const std::wstring &str)
+{
+    std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
+    return myconv.to_bytes(str);
+}
+
+std::string remove_special_chars(std::string str)
+{
+    for (char &c : str) {
+        switch (c) {
+        case '/':
+        case '\\':
+        case ':':
+        case '?':
+        case '"':
+        case '<':
+        case '>':
+        case '|':
+        case '*':
+            c = '_';
+            break;
+        default:
+            continue;
+        }
+    }
+    return str;
+}
+
+// Based on: https://stackoverflow.com/a/23135441
+// Search and replace "in" with "out" in the given string
+void replace(std::string &str, const std::string &in, const std::string &out)
+{
+    size_t pos = 0;
+    while ((pos = str.find(in, pos)) != std::string::npos) {
+        str.replace(pos, in.length(), out);
+        pos += out.length();
+    }
+}
+
+std::vector<uint8_t> string_to_byte_array(const std::string &string)
+{
+    std::vector<uint8_t> hex_bytes;
+    hex_bytes.reserve(string.length() / 2);
+
+    if (string.length() % 2 != 0)
+        LOG_WARN("Hex string length ({}) is not even", string.length());
+
+    for (size_t i = 0; i < string.length(); i += 2) {
+        std::string byte = string.substr(i, 2);
+        hex_bytes.push_back(static_cast<uint8_t>(std::strtoul(byte.c_str(), nullptr, 16)));
+    }
+    return hex_bytes;
+}
+
+#ifdef _MSC_VER
+std::string utf16_to_utf8(const std::u16string &str)
+{
+    std::wstring_convert<std::codecvt_utf8_utf16<int16_t>, int16_t> myconv;
+    auto p = reinterpret_cast<const int16_t *>(str.data());
+    return myconv.to_bytes(p, p + str.size());
+}
+
+std::u16string utf8_to_utf16(const std::string &str)
+{
+    static_assert(sizeof(std::wstring::value_type) == sizeof(std::u16string::value_type),
+                  "std::wstring and std::u16string are expected to have the same character size");
+
+    std::wstring_convert<std::codecvt_utf8_utf16<int16_t>, int16_t> myconv;
+    const char *p = str.data();
+    auto a = myconv.from_bytes(p, p + str.size());
+    return std::u16string(a.begin(), a.end());
+}
+#else
+std::string utf16_to_utf8(const std::u16string &str)
+{
+    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> myconv;
+    return myconv.to_bytes(str);
+}
+
+std::u16string utf8_to_utf16(const std::string &str)
+{
+    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> myconv;
+    return myconv.from_bytes(str);
+}
+#endif
+
+std::string toupper(const std::string &s)
+{
+    std::string r = s;
+    std::transform(r.begin(), r.end(), r.begin(), [](unsigned char c) { return std::toupper(c); });
+    return r;
+}
+
+std::string tolower(const std::string &s)
+{
+    std::string r = s;
+    std::transform(r.begin(), r.end(), r.begin(), [](unsigned char c) { return std::tolower(c); });
+    return r;
+}
+
+int stoi_def(const std::string &str, int default_value, const char *name)
+{
+    try {
+        return std::stoi(str);
+    } catch (std::invalid_argument &_) {
+        LOG_ERROR("Invalid {}: \"{}\"", name, str);
+    } catch (std::out_of_range &_) {
+        LOG_ERROR("Out of range {}: \"{}\"", name, str);
+    }
+    return default_value;
+}
+
+} // namespace string_utils