Android build

.gitignore

@@ -13,6 +13,7 @@
 .DS_Store
 .vscode
 .vs
+.cache
 /S2
 /build
 /external/boost*

CMakeLists.txt

@@ -22,7 +22,7 @@ if(DEFINED CMAKE_TOOLCHAIN_FILE)
     message(STATUS "Used Toolchain definition file '${CMAKE_TOOLCHAIN_FILE}'")
 endif()
 
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules" "${CMAKE_SOURCE_DIR}/external/libutil/cmake")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules" "${CMAKE_CURRENT_SOURCE_DIR}/external/libutil/cmake")
 
 include(EnableCCache)
 
@@ -242,6 +242,7 @@ include(RttrCoverageCfg)
 include(EnableSanitizers)
 
 option(RTTR_USE_SYSTEM_LIBS "Default to using system-wide installed libs for external dependencies that have known system versions." OFF)
+option(RTTR_BUILD_LIB "Executables will be build as shared library." OFF)
 
 ################################################################################
 # Configure files

copyDepsToBuildDir.cmake

@@ -5,7 +5,7 @@
 # Needs to be configured with @ONLY and called with -DCMAKE_BUILD_TYPE=...
 
 set(CMAKE_HOST_UNIX "@CMAKE_HOST_UNIX@")
-set(CMAKE_SOURCE_DIR "@CMAKE_SOURCE_DIR@")
+set(CMAKE_SOURCE_DIR "@CMAKE_CURRENT_SOURCE_DIR@")
 set(RTTR_TRANSLATION_OUTPUT "@RTTR_TRANSLATION_OUTPUT@")
 set(RTTR_DATADIR "@RTTR_DATADIR@")
 set(RTTR_GAMEDIR "@RTTR_GAMEDIR@")

external/glad/CMakeLists.txt

@@ -9,27 +9,41 @@ include(ConstrainedOption)
 constrained_option(RTTR_OPENGL
     DEFAULT "OGL2.0Compat"
     DESCRIPTION "The OpenGL version to use"
-    VALUES OGL2.0Compat OGL2.0 OGL2.1Compat OGL2.1 OGL3.3 GLES2.0)
+    VALUES OGL2.0Compat OGL2.0 OGL2.1Compat OGL2.1 OGL3.3 GLES2.0 GL4ES)
 
-string(REGEX MATCH "^(OGL|GLES)([0-9])\\.([0-9])(Compat)?$" ogl_match ${RTTR_OPENGL})
-if(NOT ogl_match)
-    message(FATAL_ERROR "Invalid value for RTTR_OPENGL: ${RTTR_OPENGL}.")
-endif()
-set(RTTR_OGL_MAJOR ${CMAKE_MATCH_2})
-set(RTTR_OGL_MINOR ${CMAKE_MATCH_3})
-if(CMAKE_MATCH_1 STREQUAL "GLES")
-    set(RTTR_OGL_ES 1)
-    set(rttr_glad_folder "OpenGLES")
-else()
+# gl4es OpenGL 2.1 -> GL ES 2.0 https://github.com/ptitSeb/gl4es
+if(RTTR_OPENGL STREQUAL "GL4ES")
+    set(RTTR_OGL_MAJOR 2)
+    set(RTTR_OGL_MINOR 0)
     set(RTTR_OGL_ES 0)
-    set(rttr_glad_folder "OpenGL")
-endif()
-if(CMAKE_MATCH_4 STREQUAL "Compat")
-    set(RTTR_OGL_COMPAT 1)
-else()
     set(RTTR_OGL_COMPAT 0)
+    set(RTTR_OGL_GL4ES 1)
+
+    # Use default glad for gl4es
+    set(rttr_glad_folder "OpenGL2.0Compat")
+
+else()
+    set(RTTR_OGL_GL4ES 0)
+    string(REGEX MATCH "^(OGL|GLES)([0-9])\\.([0-9])(Compat)?$" ogl_match ${RTTR_OPENGL})
+    if(NOT ogl_match)
+        message(FATAL_ERROR "Invalid value for RTTR_OPENGL: ${RTTR_OPENGL}.")
+    endif()
+    set(RTTR_OGL_MAJOR ${CMAKE_MATCH_2})
+    set(RTTR_OGL_MINOR ${CMAKE_MATCH_3})
+    if(CMAKE_MATCH_1 STREQUAL "GLES")
+        set(RTTR_OGL_ES 1)
+        set(rttr_glad_folder "OpenGLES")
+    else()
+        set(RTTR_OGL_ES 0)
+        set(rttr_glad_folder "OpenGL")
+    endif()
+    if(CMAKE_MATCH_4 STREQUAL "Compat")
+        set(RTTR_OGL_COMPAT 1)
+    else()
+        set(RTTR_OGL_COMPAT 0)
+    endif()
+    get_filename_component(rttr_glad_folder "${rttr_glad_folder}${RTTR_OGL_MAJOR}.${RTTR_OGL_MINOR}${CMAKE_MATCH_4}" ABSOLUTE)
 endif()
-get_filename_component(rttr_glad_folder "${rttr_glad_folder}${RTTR_OGL_MAJOR}.${RTTR_OGL_MINOR}${CMAKE_MATCH_4}" ABSOLUTE)
 configure_file(openglCfg.hpp.cmake include/openglCfg.hpp @ONLY)
 
 add_library(glad STATIC ${rttr_glad_folder}/src/glad.c)

external/glad/openglCfg.hpp.cmake

@@ -12,5 +12,8 @@
 #define RTTR_OGL_ES @RTTR_OGL_ES@
 // True(thy) if OpenGL compatibility profile should be used
 #define RTTR_OGL_COMPAT @RTTR_OGL_COMPAT@
+// True(thy) if gl4es should be used
+#define RTTR_OGL_GL4ES @RTTR_OGL_GL4ES@
+
 
 #endif

extras/videoDrivers/CMakeLists.txt

@@ -6,4 +6,4 @@ rttr_set_output_dir(RUNTIME ${RTTR_DRIVERDIR}/video)
 rttr_set_output_dir(LIBRARY ${RTTR_DRIVERDIR}/video)
 
 add_subdirectory(WinAPI)
-add_subdirectory(SDL2)
+add_subdirectory(SDL2)

extras/videoDrivers/SDL2/CMakeLists.txt

@@ -7,7 +7,26 @@ find_package(SDL2 2.0.5)
 
 if(SDL2_FOUND)
     add_library(videoSDL2 SHARED ${RTTR_DRIVER_INTERFACE} VideoSDL2.cpp VideoSDL2.h icon.h icon.cpp)
-    target_link_libraries(videoSDL2 PRIVATE videodrv s25util::common glad Boost::nowide SDL2::SDL2)
+
+    if(RTTR_OPENGL STREQUAL "GL4ES")
+        if(NOT TARGET GL)
+            message(STATUS "Fetching gl4es from repository...")
+            include(FetchContent)
+            FetchContent_Declare(
+              gl4es
+              GIT_REPOSITORY https://github.com/ptitSeb/gl4es
+              GIT_TAG master
+            )
+            FetchContent_MakeAvailable(gl4es)
+            target_include_directories(videoSDL2 PRIVATE
+              ${gl4es_SOURCE_DIR}/include
+            )
+        endif()
+        # gl4es generates "GL" library
+        target_link_libraries(videoSDL2 PRIVATE videodrv s25util::common glad Boost::nowide SDL2::SDL2 GL)
+    else()
+        target_link_libraries(videoSDL2 PRIVATE videodrv s25util::common glad Boost::nowide SDL2::SDL2)
+    endif()
     enable_warnings(videoSDL2)
 
     if(WIN32)
@@ -20,4 +39,4 @@ if(SDL2_FOUND)
       LIBRARY DESTINATION ${RTTR_DRIVERDIR}/video
     )
     add_dependencies(drivers videoSDL2)
-endif()
+endif()

extras/videoDrivers/SDL2/VideoSDL2.cpp

@@ -14,6 +14,7 @@
 #include <s25util/utf8.h>
 #include <boost/nowide/iostream.hpp>
 #include <SDL.h>
+#include <SDL_hints.h>
 #include <algorithm>
 #include <memory>
 
@@ -25,6 +26,9 @@
 #    include <windows.h> // Avoid "Windows headers require the default packing option" due to SDL2
 #    include <SDL_syswm.h>
 #endif // _WIN32
+#if RTTR_OGL_GL4ES == 1
+#    include <gl4esinit.h>
+#endif
 
 #define CHECK_SDL(call)                 \
     do                                  \
@@ -56,7 +60,11 @@ void FreeVideoInstance(IVideoDriver* driver)
 
 const char* GetDriverName()
 {
+#if RTTR_OGL_GL4ES == 1
+    return "(SDL2) OpenGL-ES(gl4es) via SDL2-Library";
+#else
     return "(SDL2) OpenGL via SDL2-Library";
+#endif
 }
 
 VideoSDL2::VideoSDL2(VideoDriverLoaderInterface* CallBack) : VideoDriver(CallBack), window(nullptr), context(nullptr) {}
@@ -75,6 +83,8 @@ bool VideoSDL2::Initialize()
 {
     initialized = false;
     rttr::ScopedLeakDisabler _;
+    // Do not emulate mouse events using touch
+    SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0");
     if(SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
     {
         PrintError(SDL_GetError());
@@ -116,7 +126,7 @@ bool VideoSDL2::CreateScreen(const std::string& title, const VideoMode& size, bo
     CHECK_SDL(SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RTTR_OGL_MAJOR));
     CHECK_SDL(SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RTTR_OGL_MINOR));
     SDL_GLprofile profile;
-    if((RTTR_OGL_ES))
+    if((RTTR_OGL_ES) || (RTTR_OGL_GL4ES == 1))
         profile = SDL_GL_CONTEXT_PROFILE_ES;
     else if((RTTR_OGL_COMPAT))
         profile = SDL_GL_CONTEXT_PROFILE_COMPATIBILITY;
@@ -414,6 +424,50 @@ bool VideoSDL2::MessageLoop()
                 }
             }
             break;
+            case SDL_FINGERDOWN:
+            {
+                VideoMode wnSize = GetWindowSize();
+                mouse_xy.pos = getGuiScale().screenToView(Position(static_cast<int>(ev.tfinger.x * wnSize.width),
+                                                                   static_cast<int>(ev.tfinger.y * wnSize.height)));
+                mouse_xy.ldown = true;
+                mouse_xy.num_tfingers++;
+                CallBack->Msg_LeftDown(mouse_xy);
+                break;
+            }
+            case SDL_FINGERUP:
+            {
+                VideoMode wnSize = GetWindowSize();
+                mouse_xy.pos = getGuiScale().screenToView(Position(static_cast<int>(ev.tfinger.x * wnSize.width),
+                                                                   static_cast<int>(ev.tfinger.y * wnSize.height)));
+                mouse_xy.ldown = false;
+                CallBack->Msg_LeftUp(mouse_xy);
+                mouse_xy.num_tfingers--; // Dirty way to count leftUp as touch event without extra isTouch bool
+                break;
+            }
+            case SDL_FINGERMOTION:
+            {
+                VideoMode wnSize = GetWindowSize();
+                const auto newPos = getGuiScale().screenToView(Position(
+                  static_cast<int>(ev.tfinger.x * wnSize.width), static_cast<int>(ev.tfinger.y * wnSize.height)));
+
+                if(newPos != mouse_xy.pos)
+                {
+                    mouse_xy.pos = newPos;
+                    CallBack->Msg_MouseMove(mouse_xy);
+                }
+                break;
+            }
+            case SDL_MULTIGESTURE:
+            {
+                if(std::fabs(ev.mgesture.dDist) > 0.001)
+                {
+                    if(ev.mgesture.dDist > 0)
+                        CallBack->Msg_WheelUp(mouse_xy);
+                    else
+                        CallBack->Msg_WheelDown(mouse_xy);
+                }
+                break;
+            }
         }
     }
 
@@ -446,7 +500,11 @@ void VideoSDL2::ListVideoModes(std::vector<VideoMode>& video_modes) const
 
 OpenGL_Loader_Proc VideoSDL2::GetLoaderFunction() const
 {
+#if RTTR_OGL_GL4ES == 1
+    return gl4es_GetProcAddress;
+#else
     return SDL_GL_GetProcAddress;
+#endif
 }
 
 void VideoSDL2::SetMousePos(Position pos)
@@ -482,7 +540,8 @@ void VideoSDL2::MoveWindowToCenter()
     SDL_Rect usableBounds;
     CHECK_SDL(SDL_GetDisplayUsableBounds(SDL_GetWindowDisplayIndex(window), &usableBounds));
     int top, left, bottom, right;
-    CHECK_SDL(SDL_GetWindowBordersSize(window, &top, &left, &bottom, &right));
+    if(SDL_GetWindowBordersSize(window, &top, &left, &bottom, &right) != 0)
+        top = left = bottom = right = 0;
     usableBounds.w -= left + right;
     usableBounds.h -= top + bottom;
     if(usableBounds.w < GetWindowSize().width || usableBounds.h < GetWindowSize().height)

libs/driver/include/driver/MouseCoords.h

@@ -15,18 +15,19 @@
 class MouseCoords
 {
 public:
-    MouseCoords() : pos(0, 0), ldown(false), rdown(false), dbl_click(false) {}
-    MouseCoords(int x, int y, bool ldown = false, bool rdown = false, bool dbl_click = false)
-        : pos(x, y), ldown(ldown), rdown(rdown), dbl_click(dbl_click)
+    MouseCoords() : pos(0, 0), ldown(false), rdown(false), dbl_click(false), num_tfingers(0) {}
+    MouseCoords(int x, int y, bool ldown = false, bool rdown = false, bool dbl_click = false, unsigned num_tfingers = 0)
+        : pos(x, y), ldown(ldown), rdown(rdown), dbl_click(dbl_click), num_tfingers(num_tfingers)
     {}
-    MouseCoords(Position pos, bool ldown = false, bool rdown = false, bool dbl_click = false)
-        : pos(pos), ldown(ldown), rdown(rdown), dbl_click(dbl_click)
+    MouseCoords(Position pos, bool ldown = false, bool rdown = false, bool dbl_click = false, unsigned num_tfingers = 0)
+        : pos(pos), ldown(ldown), rdown(rdown), dbl_click(dbl_click), num_tfingers(num_tfingers)
     {}
 
     Position pos;
-    bool ldown;     /// Linke Maustaste gedrückt
-    bool rdown;     /// Rechte Maustaste gedrückt
-    bool dbl_click; /// Linke Maustaste - Doppelklick
+    bool ldown;            /// Linke Maustaste gedrückt
+    bool rdown;            /// Rechte Maustaste gedrückt
+    bool dbl_click;        /// Linke Maustaste - Doppelklick
+    unsigned num_tfingers; /// Anzahl Finger auf dem Display
 
     Position GetPos() const { return pos; }
 };

libs/driver/include/driver/VideoDriver.h

@@ -27,6 +27,9 @@ class VideoDriver : public IVideoDriver
     /// Funktion zum Auslesen ob die Rechte Maustaste gedrückt ist.
     bool GetMouseStateR() const override;
 
+    /// Funktion zum Auslesen ob momentan touch verwendet wird.
+    bool GetMouseTouch() const override;
+
     VideoMode GetWindowSize() const override final { return windowSize_; }
     Extent GetRenderSize() const override final { return scaledRenderSize_; }
     bool IsFullscreen() const override final { return isFullscreen_; }

libs/driver/include/driver/VideoInterface.h

@@ -57,6 +57,8 @@ class BOOST_SYMBOL_VISIBLE IVideoDriver
     virtual bool GetMouseStateL() const = 0;
     /// Return true when right mouse button is pressed
     virtual bool GetMouseStateR() const = 0;
+    /// Return true when touch is being used
+    virtual bool GetMouseTouch() const = 0;
 
     /// Get the size of the window in screen coordinates
     virtual VideoMode GetWindowSize() const = 0;

libs/driver/src/VideoDriver.cpp

@@ -50,6 +50,16 @@ bool VideoDriver::GetMouseStateR() const
     return mouse_xy.rdown;
 }
 
+/**
+ * Funktion zum Auslesen ob momentan touch verwendet wird.
+ *
+ *  @return @p true bei touch, @p false bei maus
+ */
+bool VideoDriver::GetMouseTouch() const
+{
+    return mouse_xy.num_tfingers > 0;
+}
+
 VideoMode VideoDriver::FindClosestVideoMode(const VideoMode& mode) const
 {
     std::vector<VideoMode> avModes;

libs/rttrConfig/src/RttrConfig.cpp

@@ -130,13 +130,25 @@ bool RttrConfig::Init()
     bfs::current_path(prefixPath_);
     homePath = System::getHomePath();
     pathMappings.clear();
-    pathMappings["BIN"] = RTTR_BINDIR;
-    pathMappings["EXTRA_BIN"] = RTTR_EXTRA_BINDIR;
-    pathMappings["DATA"] = RTTR_DATADIR;
-    pathMappings["GAME"] = RTTR_GAMEDIR;
-    pathMappings["LIB"] = RTTR_LIBDIR;
-    pathMappings["DRIVER"] = RTTR_DRIVERDIR;
-    pathMappings["RTTR"] = RTTR_DATADIR "/RTTR";
-    pathMappings["USERDATA"] = RTTR_USERDATADIR;
+    pathMappings["BIN"] = getEnvOverride("BIN", RTTR_BINDIR);
+    pathMappings["EXTRA_BIN"] = getEnvOverride("EXTRA_BIN", RTTR_EXTRA_BINDIR);
+    pathMappings["DATA"] = getEnvOverride("DATA", RTTR_DATADIR);
+    pathMappings["GAME"] = getEnvOverride("GAME", RTTR_GAMEDIR);
+    pathMappings["LIB"] = getEnvOverride("LIB", RTTR_LIBDIR);
+    pathMappings["DRIVER"] = getEnvOverride("DRIVER", RTTR_DRIVERDIR);
+    pathMappings["RTTR"] = getEnvOverride("RTTR", RTTR_DATADIR "/RTTR");
+    pathMappings["USERDATA"] = getEnvOverride("USERDATA", RTTR_USERDATADIR);
     return true;
 }
+
+bfs::path RttrConfig::getEnvOverride(const std::string& id, const bfs::path& defaultPath)
+{
+    bfs::path path = System::getPathFromEnvVar("RTTR_" + id + "_DIR");
+    if(!path.empty())
+    {
+        LOG.write("Note: %1% path manually set to %2%\n", LogTarget::Stdout) % id % path;
+    } else
+        return defaultPath;
+
+    return path;
+}

libs/rttrConfig/src/RttrConfig.h

@@ -16,6 +16,9 @@ class RttrConfig : public Singleton<RttrConfig>
 
 public:
     bool Init();
+
+    /// Checks the env var for path override and returns result path
+    static boost::filesystem::path getEnvOverride(const std::string& id, const boost::filesystem::path& defaultPath);
     /// Return the prefix path for the installation
     static boost::filesystem::path GetPrefixPath();
     /// Return the path from which RTTR was compiled

libs/s25client/CMakeLists.txt

@@ -18,9 +18,20 @@ else()
     set(s25client_RC )
 endif()
 
-add_executable(s25client s25client.cpp commands.cpp ${s25client_RC})
-target_link_libraries(s25client PRIVATE s25Main Boost::program_options Boost::nowide rttr::vld)
-add_dependencies(s25client drivers)
+if(RTTR_BUILD_LIB)
+    add_library(s25client SHARED s25client.cpp commands.cpp ${s25client_RC})
+else()
+    add_executable(s25client s25client.cpp commands.cpp ${s25client_RC})
+endif()
+
+if(ANDROID)
+    find_package(SDL2 2.0.5) # SDL2 android needs a specific sdl function(SDL_main) as entry point.
+    target_link_libraries(s25client PRIVATE s25Main Boost::program_options Boost::nowide rttr::vld SDL2::SDL2)
+else()
+    target_link_libraries(s25client PRIVATE s25Main Boost::program_options Boost::nowide rttr::vld)
+endif()
+
+add_dependencies(s25client drivers translations)
 
 if(WIN32)
     target_include_directories(s25client PRIVATE ${rcDir})