port more special things to the web

Author: Totto16

android/run-web.sh

@@ -26,6 +26,7 @@ if [ $BUILD_SYSTEM = "meson" ]; then
 
     export COMMON_EMSCRIPTEN_OPTIONS="'-fexceptions', '-sEXCEPTION_CATCHING_ALLOWED=[..]'"
 
+    # TODO see if ALLOW_MEMORY_GROWTH is needed, but if we load ttf's and music it likely is and we don't have to debug OOm crahses, that aren't handled by some library, which is a pain in the a**
     export LINK_EMSCRIPTEN_OPTIONS="$COMMON_EMSCRIPTEN_OPTIONS, '-sEXPORT_ALL=1', '-sUSE_GLFW=3', '-sUSE_WEBGPU=1', '-sWASM=1', '-sALLOW_MEMORY_GROWTH=1', '-sNO_EXIT_RUNTIME=0', '-sASSERTIONS=1'"
     export COMPILE_EMSCRIPTEN_OPTIONS="$COMMON_EMSCRIPTEN_OPTIONS"
 

meson.build

@@ -101,12 +101,20 @@ deps += dependency(
     default_options: sdl2_mixer_flags,
 )
 
+if meson.is_cross_build() and host_machine.system() == 'emscripten'
+
+    # this is done here, since it's only needed for one file!
+    cpp = meson.get_compiler('cpp')
+    deps += cpp.find_library('embind', required: true)
+    deps += cpp.find_library('openal', required: true)
+endif
 
 ## HEADER ONLY LIBS
 deps += dependency(
     'spdlog',
     required: true,
     native: native,
+    version: '>=1.1.11',
     default_options: ['tests=false'],
 )
 deps += dependency('nlohmann_json', required: true, native: native)
@@ -137,6 +145,9 @@ deps += dependency(
 
 
 src_files = []
+link_args = []
+link_whole = []
+
 
 subdir('src')
 
@@ -162,6 +173,8 @@ elif meson.is_cross_build() and host_machine.system() == 'emscripten'
         include_directories: inc_dirs,
         dependencies: deps,
         c_args: sdl2_mixer_defines,
+        link_whole: link_whole,
+        link_args: ['--preload-file', '../assets@/assets/'],
         cpp_args: compile_args + sdl2_mixer_defines,
         override_options: ['warning_level=3', 'werror=true'],
         native: native,

src/main.cpp

@@ -4,6 +4,8 @@
 #include <filesystem>
 #if defined(__ANDROID__)
 #include <spdlog/sinks/android_sink.h>
+#elif defined(__EMSCRIPTEN__)
+#include "web_utils.hpp"
 #endif
 #include <spdlog/sinks/basic_file_sink.h>
 #include <spdlog/sinks/rotating_file_sink.h>
@@ -17,13 +19,22 @@ int main(int argc, char** argv) {
 
     std::vector<spdlog::sink_ptr> sinks;
 #if defined(__ANDROID__)
+#define USE_FILE_LOG
     sinks.push_back(std::make_shared<spdlog::sinks::android_sink_mt>());
+#elif defined(__EMSCRIPTEN__)
+    sinks.push_back(utils::get_web_sink());
 #else
+#define USE_FILE_LOG
     sinks.push_back(std::make_shared<spdlog::sinks::stdout_sink_st>());
 #endif
+
+
+#if defined(USE_FILE_LOG)
     sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
             fmt::format("{}/oopetris.log", logs_path.string()), 1024 * 1024 * 10, 5, true
     ));
+#endif
+
     auto combined_logger = std::make_shared<spdlog::logger>("combined_logger", begin(sinks), end(sinks));
     spdlog::set_default_logger(combined_logger);
 

src/music_manager.cpp

@@ -24,6 +24,11 @@ MusicManager::MusicManager(u8 channel_size)
       m_queued_music{ nullptr },
       m_channel_size{ channel_size },
       m_chunk_map{ std::unordered_map<std::string, Mix_Chunk*>{} } {
+
+
+//TODO: debug sound issues on EMSCRIPTEN
+#if not defined(__EMSCRIPTEN__)
+
     Mix_Init(MIX_INIT_FLAC | MIX_INIT_MP3);
     const int result = SDL_InitSubSystem(SDL_INIT_AUDIO);
     if (result != 0) {
@@ -35,6 +40,8 @@ MusicManager::MusicManager(u8 channel_size)
     if (result != 0) {
         throw std::runtime_error{ "error on open the audio device: " + std::string{ Mix_GetError() } };
     }
+
+#endif
 }
 
 void MusicManager::hook_music_finished() {
@@ -63,7 +70,10 @@ void MusicManager::hook_music_finished() {
 
 
 tl::optional<std::string> MusicManager::load_and_play_music(const std::filesystem::path& location, const usize delay) {
+#if defined(__EMSCRIPTEN__)
+    return "TODO: not implemented yet";
 
+#endif
 
     Mix_Music* music = Mix_LoadMUS(location.string().c_str());
     if (music == nullptr) {

src/spdlog/callback_sink.h

@@ -0,0 +1,64 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+
+// FIXME: this is a temporary fix, since the spdlog upstream just added these 3 months ago, but didn't make a new release!!
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/synchronous_factory.h>
+
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+
+// callbacks type
+typedef std::function<void(const details::log_msg &msg)> custom_log_callback;
+
+namespace sinks {
+/*
+ * Trivial callback sink, gets a callback function and calls it on each log
+ */
+template<typename Mutex>
+class callback_sink final : public base_sink<Mutex>
+{
+public:
+    explicit callback_sink(const custom_log_callback &callback)
+        : callback_{callback}
+    {}
+
+protected:
+    void sink_it_(const details::log_msg &msg) override
+    {
+        callback_(msg);
+    }
+    void flush_() override{};
+
+private:
+    custom_log_callback callback_;
+};
+
+using callback_sink_mt = callback_sink<std::mutex>;
+using callback_sink_st = callback_sink<details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> callback_logger_mt(const std::string &logger_name, const custom_log_callback &callback)
+{
+    return Factory::template create<sinks::callback_sink_mt>(logger_name, callback);
+}
+
+template<typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> callback_logger_st(const std::string &logger_name, const custom_log_callback &callback)
+{
+    return Factory::template create<sinks::callback_sink_st>(logger_name, callback);
+}
+
+} // namespace spdlog

src/tetris_application.cpp

@@ -142,8 +142,11 @@ void TetrisApplication::render() const {
 void TetrisApplication::try_load_settings() {
     try {
 #if defined(__EMSCRIPTEN__)
-        const std::string settings_string = utils::LocalStorage::get_item(settings_filename);
-        m_settings = nlohmann::json::parse(settings_string);
+        const auto settings_string = utils::LocalStorage::get_item(settings_filename);
+        if (not settings_string.has_value()) {
+            return;
+        }
+        m_settings = nlohmann::json::parse(settings_string.value());
 #else
         m_settings = nlohmann::json::parse(settings_file);
 #endif

src/utils.cpp

@@ -42,7 +42,10 @@ namespace utils {
             throw std::runtime_error{ "Failed in getting the Pref Path: " + std::string{ SDL_GetError() } };
         }
         return std::filesystem::path{ std::string{ pref_path } };
+#elif defined(__EMSCRIPTEN__)
+        return std::filesystem::path{ "/" };
 #else
+
         // this is only used in local build for debugging, when compiling in release mode the path is real path where the app can store many things without interfering with other things (eg. AppData\Roaming\... onw Windows or  .local/share/... on Linux )
         return std::filesystem::path{ "." };
 #endif
@@ -63,6 +66,8 @@ namespace utils {
 // if you build in BUILD_INSTALLER mode, you have to assure that the data is there eg. music  + fonts!
 #endif
         return std::filesystem::path{ std::string{ resource_path } } / "assets";
+#elif defined(__EMSCRIPTEN__)
+        return std::filesystem::path{ "/assets" };
 #else
         return std::filesystem::path{ "assets" };
 #endif

src/web_utils.cpp

@@ -1,43 +1,110 @@
 
 #if defined(__EMSCRIPTEN__)
 #include "web_utils.hpp"
-#include <emscripten.h>
+#include <emscripten/val.h>
+#include <memory>
+// FIXME: this is a temporary fix, since the spdlog upstream just added these 3 months ago, but didn't make a new release!!
+#include "spdlog/callback_sink.h"
 #include <string>
 #include <tl/optional.hpp>
 
 tl::optional<std::string> utils::LocalStorage::get_item(const std::string& key) {
 
-
     thread_local const emscripten::val localStorage = emscripten::val::global("localStorage");
 
-    emscripten::val value localStorage.getItem(key.c_str());
+    emscripten::val value = localStorage.call<emscripten::val>("getItem", emscripten::val{ key });
 
-    if (value.isUndefined()) {
+    if (value.isNull()) {
         return tl::nullopt;
     }
 
-    return value.as<std::string | undefined>();
+    return value.as<std::string>();
 }
 
 void utils::LocalStorage::set_item(const std::string& key, const std::string& value) {
 
     thread_local const emscripten::val localStorage = emscripten::val::global("localStorage");
 
-    localStorage.setItem(key.c_str(), value.c_str());
+    localStorage.call<void>("setItem", emscripten::val{ key }, emscripten::val{ value });
 }
 
 void utils::LocalStorage::remove_item(const std::string& key) {
 
     thread_local const emscripten::val localStorage = emscripten::val::global("localStorage");
 
-    localStorage.removeItem(key.c_str());
+    localStorage.call<void>("removeItem", emscripten::val{ key });
 }
 
 void utils::LocalStorage::clear() {
 
     thread_local const emscripten::val localStorage = emscripten::val::global("localStorage");
 
-    localStorage.clear();
+    localStorage.call<void>("clear");
+}
+
+
+void utils::console::error(const std::string& message) {
+    thread_local const emscripten::val console = emscripten::val::global("console");
+    console.call<void>("error", emscripten::val{ message });
+}
+
+void utils::console::warn(const std::string& message) {
+    thread_local const emscripten::val console = emscripten::val::global("console");
+    console.call<void>("warn", emscripten::val{ message });
+}
+
+void utils::console::log(const std::string& message) {
+    thread_local const emscripten::val console = emscripten::val::global("console");
+    console.call<void>("log", emscripten::val{ message });
+}
+
+void utils::console::info(const std::string& message) {
+    thread_local const emscripten::val console = emscripten::val::global("console");
+    console.call<void>("info", emscripten::val{ message });
+}
+
+void utils::console::debug(const std::string& message) {
+    thread_local const emscripten::val console = emscripten::val::global("console");
+    console.call<void>("debug", emscripten::val{ message });
+}
+
+void utils::console::trace(const std::string& message) {
+    thread_local const emscripten::val console = emscripten::val::global("console");
+    console.call<void>("trace", emscripten::val{ message });
+}
+
+void utils::console::clear() {
+    thread_local const emscripten::val console = emscripten::val::global("console");
+    console.call<void>("clear");
+}
+
+std::shared_ptr<spdlog::sinks::callback_sink_mt> utils::get_web_sink() {
+    return std::make_shared<spdlog::sinks::callback_sink_mt>([](const spdlog::details::log_msg& msg) {
+        const auto message = std::string{ msg.payload.begin(), msg.payload.end() };
+
+        switch (msg.level) {
+            case spdlog::level::off:
+                return;
+            case spdlog::level::trace:
+                utils::console::trace(message);
+                break;
+            case spdlog::level::debug:
+                utils::console::debug(message);
+                break;
+            case spdlog::level::info:
+                utils::console::info(message);
+                break;
+            case spdlog::level::warn:
+                utils::console::warn(message);
+                break;
+            case spdlog::level::err:
+            case spdlog::level::critical:
+                utils::console::error(message);
+                break;
+            default:
+                return;
+        }
+    });
 }
 
 

src/web_utils.hpp

@@ -2,24 +2,39 @@
 
 #pragma once
 
-#include <string>
-#include <tl/optional.hpp>
-
-
 #if not defined(__EMSCRIPTEN__)
 #error this header is for emscripten only
 #endif
 
-namespace utils {
+#include <memory>
+#include <string>
+#include <tl/optional.hpp>
+// FIXME: this is a temporary fix, since the spdlog upstream just added these 3 months ago, but didn't make a new release!!
+#include "spdlog/callback_sink.h"
 
+namespace utils {
 
     struct LocalStorage {
 
-        static tl::optional<std::string> [[nodiscard]] get_item(const std::string& key);
+        [[nodiscard]] static tl::optional<std::string> get_item(const std::string& key);
         static void set_item(const std::string& key, const std::string& value);
         static void remove_item(const std::string& key);
         static void clear();
     };
 
+    [[nodiscard]] std::shared_ptr<spdlog::sinks::callback_sink_mt> get_web_sink();
+
+
+    namespace console {
+        void clear();
+        //TODO, these support more arguments, write templates for that
+        void error(const std::string& message);
+        void warn(const std::string& message);
+        void log(const std::string& message);
+        void info(const std::string& message);
+        void debug(const std::string& message);
+        void trace(const std::string& message);
+    }; // namespace console
+
 
 }; // namespace utils