Draw UI with OpenGL, delete Surf_Display

Keep small surface per UI component that is drawn with OpenGL
Avoids big 4K penalty while keeping change small

Author: Morgan Christiansson

CGame.cpp

@@ -77,9 +77,6 @@ int CGame::Execute()
 
 void CGame::RenderPresent()
 {
-    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);
 

CGame.h

@@ -6,7 +6,6 @@
 #pragma once
 
 #include "CIO/CFont.h"
-#include "SdlSurface.h"
 #include "Texture.h"
 #include <boost/filesystem/path.hpp>
 #include <Point.h>
@@ -27,8 +26,6 @@ class CGame
 
     bool Running;
     bool showLoadScreen;
-    SdlSurface Surf_Display;
-    Texture displayTexture_;
     SDL_GLContext glContext_ = nullptr;
     SdlWindow window_;
 
@@ -52,6 +49,8 @@ class CGame
     Texture cursor_;
     Texture cursorClicked_;
     Texture cross_;
+    Texture fpsTex_; ///< Texture for the FPS counter
+    Texture mapTex_; ///< Texture for the map/terrain (Surf_Map may be 8-bit)
 
     // structure for mouse cursor
     struct
@@ -111,6 +110,5 @@ class CGame
     CMap* getMapObj();
     void delMapObj();
     void enterEditor(const boost::filesystem::path& filepath);
-    SDL_Surface* getDisplaySurface() const { return Surf_Display.get(); };
     auto getRes() const { return GameResolution; }
 };

CGame_Init.cpp

@@ -38,8 +38,6 @@ bool CGame::CreateWindow()
     SDL_ShowWindow(window_.get());
 
     ApplyWindowChanges();
-    if(!displayTexture_.isValid() || !Surf_Display)
-        return false;
 
     SetAppIcon();
 
@@ -125,9 +123,6 @@ void CGame::UpdateDisplaySize(const Extent& newSize)
     appliedResolution_ = GameResolution;
     appliedFullscreen_ = fullscreen;
 
-    Surf_Display = makeRGBSurface(GameResolution.x, GameResolution.y, true);
-    displayTexture_.createEmpty(GameResolution);
-
     setGLViewport();
     for(auto& menu : Menus)
     {

CGame_Render.cpp

@@ -40,7 +40,6 @@ void CGame::SetAppIcon()
 void CGame::Render()
 {
     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)
@@ -50,53 +49,58 @@ void CGame::Render()
         return;
     }
 
-    // render the map if active
+    // ---- 1. Menu backgrounds are drawn via getTexture() ----
+
+    // ---- 2. Render map (software) and draw via GL ----
+    // Map renders directly to its own Surf_Map; we upload that to GL.
+    // Text overlays are written onto Surf_Map before upload.
     if(MapObj && MapObj->isActive())
     {
-        CSurface::Draw(Surf_Display, MapObj->getSurface(), 0, 0);
-        std::array<char, 100> textBuffer;
-        // text for x and y of vertex (shown in upper left corner)
-        std::snprintf(textBuffer.data(), textBuffer.size(), "%d    %d", MapObj->getVertexX(), MapObj->getVertexY());
-        CFont::writeText(Surf_Display, textBuffer.data(), Position(20, 20));
-        // text for MinReduceHeight and MaxRaiseHeight
-        std::snprintf(textBuffer.data(), textBuffer.size(),
-                      "min. height: %#04x/0x3C  max. height: %#04x/0x3C  NormalNull: 0x0A",
-                      MapObj->getMinReduceHeight(), MapObj->getMaxRaiseHeight());
-        CFont::writeText(Surf_Display, textBuffer.data(), Position(100, 20));
-        // text for MovementLocked
-        if(MapObj->isHorizontalMovementLocked() && MapObj->isVerticalMovementLocked())
-            CFont::writeText(Surf_Display, "Movement locked (F9 or F10 to unlock)", Position(20, 40), FontSize::Large,
-                             FontColor::Orange);
-        else if(MapObj->isHorizontalMovementLocked())
-            CFont::writeText(Surf_Display, "Horizontal movement locked (F9 to unlock)", Position(20, 40),
-                             FontSize::Large, FontColor::Orange);
-        else if(MapObj->isVerticalMovementLocked())
-            CFont::writeText(Surf_Display, "Vertical movement locked (F10 to unlock)", Position(20, 40),
-                             FontSize::Large, FontColor::Orange);
+        auto* mapSurf = MapObj->getSurface();
+        if(mapSurf)
+        {
+            std::array<char, 100> textBuffer;
+            std::snprintf(textBuffer.data(), textBuffer.size(), "%d    %d", MapObj->getVertexX(), MapObj->getVertexY());
+            CFont::writeText(mapSurf, textBuffer.data(), 20, 20);
+            std::snprintf(textBuffer.data(), textBuffer.size(),
+                          "min. height: %#04x/0x3C  max. height: %#04x/0x3C  NormalNull: 0x0A",
+                          MapObj->getMinReduceHeight(), MapObj->getMaxRaiseHeight());
+            CFont::writeText(mapSurf, textBuffer.data(), 100, 20);
+            if(MapObj->isHorizontalMovementLocked() && MapObj->isVerticalMovementLocked())
+                CFont::writeText(mapSurf, "Movement locked (F9 or F10 to unlock)", 20, 40, FontSize::Large,
+                                 FontColor::Orange);
+            else if(MapObj->isHorizontalMovementLocked())
+                CFont::writeText(mapSurf, "Horizontal movement locked (F9 to unlock)", 20, 40, FontSize::Large,
+                                 FontColor::Orange);
+            else if(MapObj->isVerticalMovementLocked())
+                CFont::writeText(mapSurf, "Vertical movement locked (F10 to unlock)", 20, 40, FontSize::Large,
+                                 FontColor::Orange);
+
+            mapTex_.load(mapSurf);
+            mapTex_.Draw(Rect(0, 0, GameResolution.x, GameResolution.y));
+        }
     }
 
-    // render active menus
+    // ---- 3. Draw UI controls via OpenGL ----
     for(auto& Menu : Menus)
     {
         if(Menu->isActive())
-            CSurface::Draw(Surf_Display, Menu->getSurface(), 0, 0);
+            Menu->getTexture().Draw(Rect(0, 0, GameResolution.x, GameResolution.y));
     }
 
-    // render windows ordered by priority
+    // render windows ordered by priority, lowest first
     int highestPriority = 0;
-    // first find the highest priority
     for(auto& Window : Windows)
     {
         if(Window->getPriority() > highestPriority)
             highestPriority = Window->getPriority();
     }
-    // render from lowest priority to highest
     for(int actualPriority = 0; actualPriority <= highestPriority; actualPriority++)
     {
         for(auto& Window : Windows)
         {
             if(Window->getPriority() == actualPriority)
-                CSurface::Draw(Surf_Display, Window->getSurface(), Window->getX(), Window->getY());
+                Window->getTexture().Draw(Position(Window->getX(), Window->getY()));
         }
     }
 
@@ -105,7 +109,6 @@ void CGame::Render()
 #endif
 
     ++framesPassedSinceLastFps;
-
     const auto curTicks = SDL_GetTicks();
     const auto diffTicks = curTicks - lastFpsTick;
     if(diffTicks > 1000)
@@ -114,9 +117,36 @@ void CGame::Render()
         framesPassedSinceLastFps = 0;
         lastFpsTick = curTicks;
     }
-    CSurface::Draw(Surf_Display, lastFps.getSurface(), 0, 0);
+    {
+        auto* fpsSurf = lastFps.getSurface();
+        if(fpsSurf)
+        {
+            fpsTex_.load(fpsSurf);
+            glBindTexture(GL_TEXTURE_2D, fpsTex_.getHandle());
+            glBegin(GL_QUADS);
+            glTexCoord2f(0, 0);
+            glVertex2i(0, 0);
+            glTexCoord2f(1, 0);
+            glVertex2i(fpsSurf->w, 0);
+            glTexCoord2f(1, 1);
+            glVertex2i(fpsSurf->w, fpsSurf->h);
+            glTexCoord2f(0, 1);
+            glVertex2i(0, fpsSurf->h);
+            glEnd();
+        }
+    }
+
+    // ---- 5. Cursor on top of everything ----
+    {
+        const auto& cursorImg = Cursor.clicked ? (Cursor.button.right ? cross_ : cursorClicked_) : cursor_;
+        cursorImg.Draw(Cursor.pos);
+    }
 
-    RenderPresent();
+    SDL_GL_SwapWindow(window_.get());
+
+#ifdef _ADMINMODE
+    FrameCounter++;
+#endif
 
     if(msWait)
         SDL_Delay(msWait);

CIO/CControlContainer.h

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "../Texture.h"
 #include "defines.h"
 #include <memory>
 #include <vector>
@@ -45,6 +46,7 @@ class CControlContainer
 protected:
     SdlSurface surface;
     bool needRender = true;
+    Texture surfaceTex_; ///< Texture for this container's surface (used by CWindow)
 
     void renderElements();
     auto& getTextFields() { return textfields; }
@@ -54,13 +56,22 @@ class CControlContainer
 public:
     CControlContainer(int pic_background);
     CControlContainer(int pic_background, Extent borderBeginSize, Extent borderEndSize);
-    ~CControlContainer() noexcept;
+    virtual ~CControlContainer() noexcept;
     // Access
     Extent getBorderSize() const { return borderBeginSize + borderEndSize; }
     void setBackgroundPicture(int pic_background);
     virtual void setMouseData(SDL_MouseMotionEvent motion);
     virtual void setMouseData(SDL_MouseButtonEvent button);
     void setKeyboardData(const SDL_KeyboardEvent& key);
+    /// Get the texture for this container's rendered content.
+    const Texture& getTexture()
+    {
+        render();
+        if(surface)
+            surfaceTex_.load(surface.get());
+        return surfaceTex_;
+    }
+    /// Get the raw surface for direct pixel access (minimap overlay, etc.).
     SDL_Surface* getSurface()
     {
         render();

CIO/CWindow.cpp

@@ -42,8 +42,10 @@ CWindow::CWindow(void callback(int), int callbackQuitMessage, Position pos, Exte
 static Position makePos(WindowPos pos, Extent size)
 {
     if(pos == WindowPos::Center)
-        return Position(global::s2->getDisplaySurface()->w, global::s2->getDisplaySurface()->h) / 2 - size / 2;
-    else
+    {
+        const auto res = global::s2->getRes();
+        return Position(res.x / 2, res.y / 2) - size / 2;
+    } else
         return {};
 }
 
@@ -91,12 +93,14 @@ void CWindow::setMouseData(SDL_MouseMotionEvent motion)
         // make sure to not move the window outside the display surface
         if(x_ < 0)
             x_ = 0;
-        if(x_ + w_ >= global::s2->getDisplaySurface()->w) //-V807
-            x_ = global::s2->getDisplaySurface()->w - w_ - 1;
-        if(y_ < 0)
-            y_ = 0;
-        if(y_ + h_ >= global::s2->getDisplaySurface()->h)
-            y_ = global::s2->getDisplaySurface()->h - h_ - 1;
+        {
+            const auto res = global::s2->getRes();
+            const int resW = res.x, resH = res.y;
+            if(x_ + w_ >= resW) //-V807
+                x_ = resW - w_ - 1;
+            if(y_ + h_ >= resH)
+                y_ = resH - h_ - 1;
+        }
     }
 
     // check whats happen to the close button

Texture.cpp

@@ -98,21 +98,13 @@ bool Texture::load(SDL_Surface* surface, bool filterLinear)
         return true;
     }
 
-    // 32-bit surface: convert to destination format (BGRA), force full opacity
+    // 32-bit surface: convert to destination format (BGRA).
+    // SDL_ConvertSurfaceFormat preserves color keys and alpha, so
+    // transparent pixels keep alpha=0 and text anti-aliasing is retained.
     SDL_Surface* converted = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_ARGB8888, 0);
     if(!converted)
         return false;
 
-    // Force alpha to opaque (LBM palette entries often have alpha=0)
-    SDL_LockSurface(converted);
-    for(int y = 0; y < converted->h; y++)
-    {
-        auto* row = (Uint32*)((Uint8*)converted->pixels + y * converted->pitch);
-        for(int x = 0; x < converted->w; x++)
-            row[x] |= 0xFF000000u; // set alpha bits
-    }
-    SDL_UnlockSurface(converted);
-
     load(converted->pixels, Extent(converted->w, converted->h), filterLinear);
     SDL_FreeSurface(converted);
     return true;

Texture.h

@@ -38,6 +38,18 @@ class Texture
     /// Draw the texture at native size at the given position.
     void Draw(Position pos) const;
 
+    /// Convenience overload for callers using separate x/y.
+    void Draw(int x, int y) const { Draw(Position(x, y)); }
+
+    /// Returns the raw GL texture name (for use with glBindTexture).
+    unsigned getHandle() const { return texture_; }
+
+    /// Width in pixels.
+    int getWidth() const { return size_.x; }
+
+    /// Height in pixels.
+    int getHeight() const { return size_.y; }
+
     /// Returns true if the texture has been created.
     bool isValid() const { return texture_ != 0; }
 

callbacks.cpp

@@ -19,6 +19,7 @@
 #include "globals.h"
 #include "helpers/format.hpp"
 #include "s25util/strAlgos.h"
+#include <glad/glad.h>
 #include <boost/filesystem.hpp>
 #include <algorithm>
 #include <cctype>
@@ -51,9 +52,12 @@ void callback::PleaseWait(int Param)
             WNDWait->addText("Please wait ...", Position(10, 10), FontSize::Large);
             // we need to render this window NOW, cause the render loop will do it too late (when the operation
             // is done and we don't need the "Please wait"-window anymore)
-            CSurface::Draw(global::s2->getDisplaySurface(), WNDWait->getSurface(),
-                           global::s2->getDisplaySurface()->w / 2 - 106, global::s2->getDisplaySurface()->h / 2 - 35);
-            global::s2->RenderPresent();
+            {
+                const auto res = global::s2->getRes();
+                glClear(GL_COLOR_BUFFER_BIT);
+                WNDWait->getTexture().Draw(Position(res.x / 2 - 106, res.y / 2 - 35));
+                global::s2->RenderPresent();
+            }
             break;
 
         case CALL_FROM_GAMELOOP: // This window gives a "Please Wait"-string, so it is shown while there is an intensive
@@ -2849,8 +2853,8 @@ void callback::MinimapMenu(int Param)
                 height = map->height / scaleNum;
                 //--> 12px is width of left and right window frame and 30px is height of the upper and lower window
                 // frame
-                if((global::s2->getDisplaySurface()->w - 12 < width)
-                   || (global::s2->getDisplaySurface()->h - 30 < height))
+                if((static_cast<int>(global::s2->getRes().x) - 12 < width)
+                   || (static_cast<int>(global::s2->getRes().y) - 30 < height))
                     break;
                 WNDMinimap = global::s2->RegisterWindow(
                   std::make_unique<CWindow>(MinimapMenu, WINDOWQUIT, WindowPos::Center, Extent(width + 12, height + 30),