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,24 +77,9 @@ int CGame::Execute()
 
 void CGame::RenderPresent()
 {
-    glBindTexture(GL_TEXTURE_2D, displayTex_);
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, Surf_Display->w, Surf_Display->h, GL_BGRA, GL_UNSIGNED_BYTE,
-                    Surf_Display->pixels);
-    // Screen was cleared at the start of Render(); GL-drawn backgrounds
-    // are already in the framebuffer. The Surf_Display texture (with
-    // alpha=0 for transparent areas) is blended on top via GL_BLEND.
-    glBegin(GL_QUADS);
-    glTexCoord2f(0, 0);
-    glVertex2i(0, 0);
-    glTexCoord2f(1, 0);
-    glVertex2i(GameResolution.x, 0);
-    glTexCoord2f(1, 1);
-    glVertex2i(GameResolution.x, GameResolution.y);
-    glTexCoord2f(0, 1);
-    glVertex2i(0, GameResolution.y);
-    glEnd();
-
-    // Draw cursor on top of everything
+    // Used by callbacks.cpp to flush a "Please wait" window to screen immediately.
+    // The caller is responsible for drawing (e.g. via renderGL()) before calling this.
+    // We just draw the cursor on top and swap.
     {
         const auto& cursorImg = Cursor.clicked ? (Cursor.button.right ? cross_ : cursorClicked_) : cursor_;
         cursorImg.Draw(Cursor.pos.x, Cursor.pos.y);

CGame.h

@@ -27,9 +27,7 @@ class CGame
 
     bool Running;
     bool showLoadScreen;
-    SdlSurface Surf_Display;
     SDL_GLContext glContext_ = nullptr;
-    unsigned int displayTex_ = 0;
     SdlWindow window_;
 
 private:
@@ -53,6 +51,8 @@ class CGame
     GlTexture cursor_;
     GlTexture cursorClicked_;
     GlTexture cross_;
+    GlTexture fpsTex_; ///< GL texture for the FPS counter
+    GlTexture mapTex_; ///< GL texture for the map/terrain (Surf_Map may be 8-bit)
 
     // structure for mouse cursor
     struct
@@ -76,7 +76,6 @@ class CGame
     std::unique_ptr<CMap> MapObj;
 
     void SetAppIcon();
-    void RecreateDisplayResources();
     void setGLViewport();
 
 public:
@@ -110,6 +109,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

@@ -18,11 +18,6 @@
 bool CGame::ReCreateWindow()
 {
     suppressResizeEvents_ = 3;
-    if(displayTex_)
-    {
-        glDeleteTextures(1, &displayTex_);
-        displayTex_ = 0;
-    }
     if(glContext_)
     {
         SDL_GL_DeleteContext(glContext_);
@@ -46,32 +41,10 @@ bool CGame::ReCreateWindow()
     glClearColor(0, 0, 0, 1);
     setGLViewport();
 
-    RecreateDisplayResources();
-    if(!displayTex_ || !Surf_Display)
-        return false;
-
     SetAppIcon();
     return true;
 }
 
-void CGame::RecreateDisplayResources()
-{
-    if(displayTex_)
-    {
-        glDeleteTextures(1, &displayTex_);
-        displayTex_ = 0;
-    }
-    Surf_Display = makeRGBSurface(GameResolution.x, GameResolution.y, true);
-
-    glGenTextures(1, &displayTex_);
-    glBindTexture(GL_TEXTURE_2D, displayTex_);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, GameResolution.x, GameResolution.y, 0, GL_BGRA, GL_UNSIGNED_BYTE, nullptr);
-}
-
 void CGame::setGLViewport()
 {
     glViewport(0, 0, GameResolution.x, GameResolution.y);
@@ -85,7 +58,6 @@ void CGame::setGLViewport()
 void CGame::UpdateDisplaySize(const Extent& newSize)
 {
     GameResolution = newSize;
-    RecreateDisplayResources();
     for(auto& menu : Menus)
         menu->resetSurface();
     for(auto& wnd : Windows)

CGame_Render.cpp

@@ -44,14 +44,10 @@ void CGame::Render()
     // Ensure viewport and ortho projection match current window size (handles resize)
     setGLViewport();
 
-    // Clear the framebuffer and the software overlay surface.
-    // GL draws (backgrounds) and the final Surf_Display overlay are
-    // composited via blending.
+    // Clear the framebuffer.
     glClear(GL_COLOR_BUFFER_BIT);
-    SDL_FillRect(Surf_Display.get(), nullptr, SDL_MapRGBA(Surf_Display->format, 0, 0, 0, 0));
 
-    if(Extent(Surf_Display->w, Surf_Display->h) != GameResolution
-       || fullscreen != ((SDL_GetWindowFlags(window_.get()) & SDL_WINDOW_FULLSCREEN) != 0))
+    if(fullscreen != ((SDL_GetWindowFlags(window_.get()) & SDL_WINDOW_FULLSCREEN) != 0))
     {
         ReCreateWindow();
     }
@@ -64,71 +60,75 @@ void CGame::Render()
         return;
     }
 
-    // render the map if active
-    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);
-    }
-
-    // render active menus
+    // ---- 1. Draw menu backgrounds via OpenGL ----
     for(auto& Menu : Menus)
     {
         if(Menu->isActive())
         {
-            // Draw menu background via OpenGL
             int bgIdx = Menu->getBackground();
             (bgIdx == SPLASHSCREEN_MAINMENU ? menuBgMain_ : menuBgSub_)
               .DrawFull(Rect(0, 0, GameResolution.x, GameResolution.y));
-            // Draw UI overlay on top
-            CSurface::Draw(Surf_Display, Menu->getSurface(), 0, 0);
         }
     }
 
-    // render windows ordered by priority
+    // ---- 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.
+    const bool mapActive = (MapObj && MapObj->isActive());
+    if(mapActive)
+    {
+        auto* mapSurf = MapObj->getSurface();
+        if(mapSurf)
+        {
+            // Write text overlays directly onto the map surface
+            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);
+
+            // Upload map surface — handles 8-bit paletted (classic) and 32-bit
+            mapTex_.load(mapSurf);
+            mapTex_.DrawFull(Rect(0, 0, GameResolution.x, GameResolution.y));
+        }
+    }
+
+    // ---- 3. Draw UI controls via OpenGL ----
+    for(auto& Menu : Menus)
+    {
+        if(Menu->isActive())
+            Menu->renderGL(0, 0);
+    }
+
+    // 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->renderGL(Window->getX(), Window->getY());
         }
     }
 
-    // Cursor is drawn in RenderPresent via GL (after the Surf_Display overlay)
-
-#ifdef _ADMINMODE
-    FrameCounter++;
-#endif
-
+    // ---- 4. Draw FPS counter via GL ----
     ++framesPassedSinceLastFps;
-
     const auto curTicks = SDL_GetTicks();
     const auto diffTicks = curTicks - lastFpsTick;
     if(diffTicks > 1000)
@@ -137,9 +137,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();
+        }
+    }
 
-    RenderPresent();
+    // ---- 5. Cursor on top of everything ----
+    {
+        const auto& cursorImg = Cursor.clicked ? (Cursor.button.right ? cross_ : cursorClicked_) : cursor_;
+        cursorImg.Draw(Cursor.pos.x, Cursor.pos.y);
+    }
+
+    SDL_GL_SwapWindow(window_.get());
+
+#ifdef _ADMINMODE
+    FrameCounter++;
+#endif
 
     if(msWait)
         SDL_Delay(msWait);

CIO/CControlContainer.cpp

@@ -12,6 +12,7 @@
 #include "CSelectBox.h"
 #include "CTextfield.h"
 #include "helpers/containerUtils.h"
+#include <glad/glad.h>
 
 CControlContainer::CControlContainer(int pic_background)
     : CControlContainer(pic_background, Extent::all(0), Extent::all(0))
@@ -203,3 +204,84 @@ void CControlContainer::renderElements()
     for(const auto& static_picture : static_pictures)
         CSurface::Draw(surface, global::bmpArray[static_picture.pic].surface, static_picture.pos);
 }
+
+static void drawTexturedQuad(int x, int y, int w, int h)
+{
+    glBegin(GL_QUADS);
+    glTexCoord2f(0, 0);
+    glVertex2i(x, y);
+    glTexCoord2f(1, 0);
+    glVertex2i(x + w, y);
+    glTexCoord2f(1, 1);
+    glVertex2i(x + w, y + h);
+    glTexCoord2f(0, 1);
+    glVertex2i(x, y + h);
+    glEnd();
+}
+
+void CControlContainer::renderGL(int baseX, int baseY)
+{
+    for(const auto& picture : pictures)
+    {
+        auto* surf = picture->getSurface();
+        if(!surf)
+            continue;
+        auto& entry = childTexCache_[surf];
+        entry.tex.load(surf);
+        glBindTexture(GL_TEXTURE_2D, entry.tex.getHandle());
+        drawTexturedQuad(baseX + picture->getX(), baseY + picture->getY(), entry.tex.getWidth(), entry.tex.getHeight());
+    }
+    for(const auto& text : texts)
+    {
+        auto* surf = text->getSurface();
+        if(!surf)
+            continue;
+        auto& entry = childTexCache_[surf];
+        entry.tex.load(surf);
+        glBindTexture(GL_TEXTURE_2D, entry.tex.getHandle());
+        drawTexturedQuad(baseX + text->getX(), baseY + text->getY(), entry.tex.getWidth(), entry.tex.getHeight());
+    }
+    for(const auto& textfield : textfields)
+    {
+        auto* surf = textfield->getSurface();
+        if(!surf)
+            continue;
+        auto& entry = childTexCache_[surf];
+        entry.tex.load(surf);
+        glBindTexture(GL_TEXTURE_2D, entry.tex.getHandle());
+        drawTexturedQuad(baseX + textfield->getX(), baseY + textfield->getY(), entry.tex.getWidth(),
+                         entry.tex.getHeight());
+    }
+    for(const auto& selectbox : selectboxes)
+    {
+        SDL_Surface* surf = selectbox->getSurface().get();
+        if(!surf)
+            continue;
+        auto& entry = childTexCache_[surf];
+        entry.tex.load(surf);
+        glBindTexture(GL_TEXTURE_2D, entry.tex.getHandle());
+        const auto& pos = selectbox->getPos();
+        drawTexturedQuad(baseX + pos.x, baseY + pos.y, entry.tex.getWidth(), entry.tex.getHeight());
+    }
+    for(const auto& button : buttons)
+    {
+        auto* surf = button->getSurface();
+        if(!surf)
+            continue;
+        auto& entry = childTexCache_[surf];
+        entry.tex.load(surf);
+        glBindTexture(GL_TEXTURE_2D, entry.tex.getHandle());
+        drawTexturedQuad(baseX + button->getX(), baseY + button->getY(), entry.tex.getWidth(), entry.tex.getHeight());
+    }
+    for(const auto& static_picture : static_pictures)
+    {
+        auto* srcSurf = global::bmpArray[static_picture.pic].surface.get();
+        if(!srcSurf)
+            continue;
+        auto& entry = staticTexCache_[static_picture.pic];
+        entry.load(srcSurf);
+        glBindTexture(GL_TEXTURE_2D, entry.getHandle());
+        drawTexturedQuad(baseX + static_picture.pos.x, baseY + static_picture.pos.y, entry.getWidth(),
+                         entry.getHeight());
+    }
+}