Merge pull request #50 from morganchristiansson/gl2-backgrounds

OpenGL backgrounds (splash, menu, options) and cursor

Author: Flamefire

CGame.cpp

@@ -13,6 +13,7 @@
 #include "s25util/file_handle.h"
 #include <libsiedler2/ArchivItem_Ini.h>
 #include <libsiedler2/libsiedler2.h>
+#include <glad/glad.h>
 #include <boost/filesystem.hpp>
 #include <boost/nowide/cstdio.hpp>
 #include <boost/program_options.hpp>
@@ -43,6 +44,11 @@ CGame::CGame(Extent GameResolution_, bool fullscreen_)
 
 CGame::~CGame()
 {
+    if(glContext_)
+    {
+        SDL_GL_DeleteContext(glContext_);
+        glContext_ = nullptr;
+    }
     global::s2 = nullptr;
 }
 
@@ -69,12 +75,15 @@ int CGame::Execute()
     return 0;
 }
 
-void CGame::RenderPresent() const
+void CGame::RenderPresent()
 {
-    SDL_UpdateTexture(displayTexture_.get(), nullptr, Surf_Display->pixels, Surf_Display->w * sizeof(Uint32));
-    SDL_RenderClear(renderer_.get());
-    SDL_RenderCopy(renderer_.get(), displayTexture_.get(), nullptr, nullptr);
-    SDL_RenderPresent(renderer_.get());
+    displayTexture_.upload(Surf_Display->pixels);
+    displayTexture_.Draw(Rect(0, 0, GameResolution.x, GameResolution.y));
+
+    const auto& cursorImg = Cursor.clicked ? (Cursor.button.right ? cross_ : cursorClicked_) : cursor_;
+    cursorImg.Draw(Cursor.pos);
+
+    SDL_GL_SwapWindow(window_.get());
 }
 
 CMenu* CGame::RegisterMenu(std::unique_ptr<CMenu> Menu)

CGame.h

@@ -7,6 +7,7 @@
 
 #include "CIO/CFont.h"
 #include "SdlSurface.h"
+#include "Texture.h"
 #include <boost/filesystem/path.hpp>
 #include <Point.h>
 #include <memory>
@@ -27,8 +28,8 @@ class CGame
     bool Running;
     bool showLoadScreen;
     SdlSurface Surf_Display;
-    SdlTexture displayTexture_;
-    SdlRenderer renderer_;
+    Texture displayTexture_;
+    SDL_GLContext glContext_ = nullptr;
     SdlWindow window_;
 
 private:
@@ -43,7 +44,14 @@ class CGame
     CFont lastFps;
 
     Uint32 lastFrameTime = 0;
-    unsigned suppressResizeEvents_ = 0;
+    Extent appliedResolution_ = Extent{0, 0}; ///< Last resolution we applied to the window/display
+    bool appliedFullscreen_ = false;          ///< Last fullscreen state we applied
+
+    // Textures for splash screen and cursor
+    Texture splashBg_;
+    Texture cursor_;
+    Texture cursorClicked_;
+    Texture cross_;
 
     // structure for mouse cursor
     struct
@@ -67,9 +75,13 @@ class CGame
     std::unique_ptr<CMap> MapObj;
 
     void SetAppIcon();
-    void RecreateDisplayResources();
+    void setGLViewport();
+    bool CreateWindow();
 
 public:
+    // Apply current GameResolution and fullscreen settings to the window/display.
+    void ApplyWindowChanges();
+
     void LoadSettings();
     void SaveSettings() const;
 
@@ -79,7 +91,6 @@ class CGame
     int Execute();
 
     bool Init();
-    bool ReCreateWindow();
     void UpdateDisplaySize(const Extent& newSize);
 
     void EventHandling(SDL_Event* Event);
@@ -88,7 +99,7 @@ class CGame
 
     void Render();
 
-    void RenderPresent() const;
+    void RenderPresent();
 
     CMenu* RegisterMenu(std::unique_ptr<CMenu> Menu);
     bool UnregisterMenu(CMenu* Menu);

CGame_Event.cpp

@@ -68,6 +68,7 @@ void CGame::EventHandling(SDL_Event* Event)
                     if(Event->key.keysym.mod & KMOD_ALT)
                     {
                         fullscreen = !fullscreen;
+                        ApplyWindowChanges();
                         SaveSettings();
                     }
                     break;
@@ -388,12 +389,16 @@ void CGame::EventHandling(SDL_Event* Event)
         {
             if(Event->window.event == SDL_WINDOWEVENT_RESIZED)
             {
-                if(suppressResizeEvents_ > 0)
-                {
-                    suppressResizeEvents_--;
-                    break; // Skip stale event from our own window recreation
-                }
-                UpdateDisplaySize(Extent(Event->window.data1, Event->window.data2));
+                // In fullscreen the compositor (e.g. Wayland) may report a size
+                // different from the one we requested. We already applied the
+                // resolution ourselves, so don't let the event override it.
+                if(fullscreen)
+                    break;
+                const Extent newSize(Event->window.data1, Event->window.data2);
+                // Ignore events matching the resolution we already applied.
+                if(newSize == appliedResolution_)
+                    break;
+                UpdateDisplaySize(newSize);
             }
             break;
         }

CGame_Init.cpp

@@ -8,49 +8,131 @@
 #include "CIO/CMenu.h"
 #include "CIO/CWindow.h"
 #include "CMap.h"
-#include "CSurface.h"
 #include "callbacks.h"
 #include "globals.h"
 #include "lua/GameDataLoader.h"
+#include <glad/glad.h>
 #include <iostream>
-#include <vector>
 
-bool CGame::ReCreateWindow()
+bool CGame::CreateWindow()
 {
-    suppressResizeEvents_ = 3;
-    displayTexture_.reset();
-    renderer_.reset();
-    window_.reset();
+    if(window_)
+        return false;
+
     window_.reset(SDL_CreateWindow("Return to the Roots Map editor [BETA]", SDL_WINDOWPOS_CENTERED,
                                    SDL_WINDOWPOS_CENTERED, GameResolution.x, GameResolution.y,
-                                   fullscreen ? SDL_WINDOW_FULLSCREEN : SDL_WINDOW_RESIZABLE));
+                                   SDL_WINDOW_HIDDEN | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE));
     if(!window_)
         return false;
-    renderer_.reset(SDL_CreateRenderer(window_.get(), -1, 0));
-    if(!renderer_)
+
+    glContext_ = SDL_GL_CreateContext(window_.get());
+    if(!glContext_ || !gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress))
         return false;
-    RecreateDisplayResources();
-    if(!displayTexture_ || !Surf_Display)
+
+    glEnable(GL_TEXTURE_2D);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glDisable(GL_DEPTH_TEST);
+    glClearColor(0, 0, 0, 1);
+
+    SDL_ShowWindow(window_.get());
+
+    ApplyWindowChanges();
+    if(!displayTexture_.isValid() || !Surf_Display)
         return false;
 
     SetAppIcon();
+
     return true;
 }
 
-void CGame::RecreateDisplayResources()
+void CGame::ApplyWindowChanges()
 {
-    displayTexture_.reset();
-    displayTexture_ = makeSdlTexture(renderer_, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, GameResolution.x,
-                                     GameResolution.y);
-    Surf_Display = makeRGBSurface(GameResolution.x, GameResolution.y, true);
+    if(!window_)
+        return;
+
+    if(fullscreen)
+    {
+        SDL_DisplayMode dm;
+        SDL_zero(dm);
+        dm.w = static_cast<int>(GameResolution.x);
+        dm.h = static_cast<int>(GameResolution.y);
+        dm.format = 0; // let SDL pick a supported format
+        dm.refresh_rate = 0;
+        if(SDL_SetWindowDisplayMode(window_.get(), &dm) != 0)
+        {
+            std::cerr << "SDL_SetWindowDisplayMode failed: " << SDL_GetError() << std::endl;
+            return;
+        }
+
+        const Uint32 flags = SDL_GetWindowFlags(window_.get());
+        if(!(flags & SDL_WINDOW_FULLSCREEN))
+        {
+            if(SDL_SetWindowFullscreen(window_.get(), SDL_WINDOW_FULLSCREEN) != 0)
+            {
+                std::cerr << "SDL_SetWindowFullscreen failed: " << SDL_GetError() << std::endl;
+                return;
+            }
+        } else if(GameResolution != appliedResolution_)
+        {
+            // Already fullscreen and the resolution changed. Toggle fullscreen off and
+            // back on so SDL/Wayland actually applies the new display mode.
+            if(SDL_SetWindowFullscreen(window_.get(), 0) != 0)
+            {
+                std::cerr << "SDL_SetWindowFullscreen(0) failed: " << SDL_GetError() << std::endl;
+                return;
+            }
+            SDL_SetWindowSize(window_.get(), GameResolution.x, GameResolution.y);
+            if(SDL_SetWindowFullscreen(window_.get(), SDL_WINDOW_FULLSCREEN) != 0)
+            {
+                std::cerr << "SDL_SetWindowFullscreen failed: " << SDL_GetError() << std::endl;
+                return;
+            }
+        }
+    } else
+    {
+        if(SDL_SetWindowFullscreen(window_.get(), 0) != 0)
+        {
+            std::cerr << "SDL_SetWindowFullscreen failed: " << SDL_GetError() << std::endl;
+            return;
+        }
+        SDL_SetWindowSize(window_.get(), GameResolution.x, GameResolution.y);
+        SDL_SetWindowPosition(window_.get(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+    }
+
+    UpdateDisplaySize(GameResolution);
+}
+
+void CGame::setGLViewport()
+{
+    if(!window_)
+        return;
+    int w = 0, h = 0;
+    SDL_GL_GetDrawableSize(window_.get(), &w, &h);
+    if(w == 0 || h == 0)
+        return;
+    glViewport(0, 0, w, h);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glOrtho(0, GameResolution.x, GameResolution.y, 0, -1, 1);
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
 }
 
 void CGame::UpdateDisplaySize(const Extent& newSize)
 {
     GameResolution = newSize;
-    RecreateDisplayResources();
+    appliedResolution_ = GameResolution;
+    appliedFullscreen_ = fullscreen;
+
+    Surf_Display = makeRGBSurface(GameResolution.x, GameResolution.y, true);
+    displayTexture_.createEmpty(GameResolution);
+
+    setGLViewport();
     for(auto& menu : Menus)
+    {
         menu->resetSurface();
+    }
     for(auto& wnd : Windows)
         wnd->resetSurface();
 }
@@ -62,7 +144,7 @@ bool CGame::Init()
     SDL_ShowCursor(SDL_DISABLE);
 
     std::cout << "Create Window...";
-    if(!ReCreateWindow())
+    if(!CreateWindow())
     {
         std::cout << "failure";
         return false;
@@ -94,10 +176,14 @@ bool CGame::Init()
         }
     }
 
+    // Create texture for splash background
+    splashBg_.load(global::bmpArray[SPLASHSCREEN_LOADING_S2SCREEN].surface.get(), true);
+
     // std::cout << "\nShow loading screen...";
     showLoadScreen = true;
-    CSurface::DrawStretched(Surf_Display, global::bmpArray[SPLASHSCREEN_LOADING_S2SCREEN].surface);
-    RenderPresent();
+    glClear(GL_COLOR_BUFFER_BIT);
+    splashBg_.Draw(Rect(0, 0, GameResolution.x, GameResolution.y));
+    SDL_GL_SwapWindow(window_.get());
 
     GameDataLoader gdLoader(global::worldDesc);
     if(!gdLoader.Load())
@@ -252,5 +338,10 @@ bool CGame::Init()
     // create the mainmenu
     callback::mainmenu(INITIALIZING_CALL);
 
+    // Create textures for cursor
+    cursor_.load(global::bmpArray[CURSOR].surface.get());
+    cursorClicked_.load(global::bmpArray[CURSOR_CLICKED].surface.get());
+    cross_.load(global::bmpArray[CROSS].surface.get());
+
     return true;
 }

CGame_Render.cpp

@@ -10,6 +10,7 @@
 #include "CMap.h"
 #include "CSurface.h"
 #include "globals.h"
+#include <glad/glad.h>
 #ifdef _WIN32
 #    include "s25editResource.h"
 #    ifndef WIN32_LEAN_AND_MEAN
@@ -38,18 +39,14 @@ void CGame::SetAppIcon()
 
 void CGame::Render()
 {
-    suppressResizeEvents_ = 0;
-    if(Extent(Surf_Display->w, Surf_Display->h) != GameResolution
-       || fullscreen != ((SDL_GetWindowFlags(window_.get()) & SDL_WINDOW_FULLSCREEN) != 0))
-    {
-        ReCreateWindow();
-    }
+    glClear(GL_COLOR_BUFFER_BIT);
+    SDL_FillRect(Surf_Display.get(), nullptr, SDL_MapRGBA(Surf_Display->format, 0, 0, 0, 0));
 
     // if the S2 loading screen is shown, render only this until user clicks a mouse button
     if(showLoadScreen)
     {
-        CSurface::DrawStretched(Surf_Display, global::bmpArray[SPLASHSCREEN_LOADING_S2SCREEN].surface);
-        RenderPresent();
+        splashBg_.Draw(Rect(0, 0, GameResolution.x, GameResolution.y));
+        SDL_GL_SwapWindow(window_.get());
         return;
     }
 
@@ -103,16 +100,6 @@ void CGame::Render()
         }
     }
 
-    // render mouse cursor
-    if(Cursor.clicked)
-    {
-        if(Cursor.button.right)
-            CSurface::Draw(Surf_Display, global::bmpArray[CROSS].surface, Cursor.pos);
-        else
-            CSurface::Draw(Surf_Display, global::bmpArray[CURSOR_CLICKED].surface, Cursor.pos);
-    } else
-        CSurface::Draw(Surf_Display, global::bmpArray[CURSOR].surface, Cursor.pos);
-
 #ifdef _ADMINMODE
     FrameCounter++;
 #endif

CIO/CFile.cpp

@@ -291,6 +291,7 @@ bool CFile::read_bbm(FILE* fp)
         CHECK_READ(libendian::read(&(color.r), 1, fp));
         CHECK_READ(libendian::read(&(color.g), 1, fp));
         CHECK_READ(libendian::read(&(color.b), 1, fp));
+        color.a = 255;
     }
 
     palArray++;
@@ -1250,6 +1251,7 @@ bool CFile::read_bob05(FILE* fp)
         CHECK_READ(libendian::read(&(color.r), 1, fp));
         CHECK_READ(libendian::read(&(color.g), 1, fp));
         CHECK_READ(libendian::read(&(color.b), 1, fp));
+        color.a = 255;
     }
 
     palArray++;