drawMinimap

Author: morganchristiansson

CIO/CMinimapWindow.cpp

@@ -7,6 +7,7 @@
 #include "../CMap.h"
 #include "../Texture.h"
 #include "../globals.h"
+#include "CFont.h"
 
 void CMinimapWindow::Draw(Position /*parentOrigin*/)
 {
@@ -24,24 +25,58 @@ void CMinimapWindow::Draw(Position /*parentOrigin*/)
     if(contentW <= 0 || contentH <= 0)
         return;
 
-    // Draw minimap terrain overlay onto a temporary SDL surface, then upload to texture
-    if(auto* map = global::s2->getMapObj())
+    auto* map = global::s2->getMapObj();
+    if(!map)
+        return;
+
+    // Fill pixel buffer with minimap terrain
+    int num_x = 1, num_y = 1;
+    map->drawMinimap(pixels_, contentW, contentH, num_x, num_y);
+
+    // Upload to texture and draw
+    if(!minimapTex_.isValid() || minimapTex_.getWidth() != contentW || minimapTex_.getHeight() != contentH)
+        minimapTex_.createEmpty(Extent(contentW, contentH));
+    minimapTex_.upload(pixels_.data());
+    minimapTex_.Draw(Rect(contentX, contentY, contentW, contentH));
+
+    // Draw player flags and numbers on top
+    for(int i = 0; i < MAXPLAYERS; i++)
     {
-        // Create or resize the minimap surface
-        if(!minimapSurface_ || minimapSurface_->w != contentW || minimapSurface_->h != contentH)
-            minimapSurface_ = makeRGBSurface(static_cast<unsigned>(contentW), static_cast<unsigned>(contentH), true);
+        const auto hqX = map->getPlayerHQx()[i];
+        const auto hqY = map->getPlayerHQy()[i];
+        if(hqX == 0xFFFF || hqY == 0xFFFF)
+            continue;
 
-        if(minimapSurface_)
+        const int flagIdx = FLAG_BLUE_DARK + i % 7;
+        const auto& flagBmp = global::bmpArray[flagIdx];
+        auto& flagTex = getBmpTexture(flagIdx);
+        if(flagTex.isValid())
         {
-            // Clear with transparency
-            SDL_FillRect(minimapSurface_.get(), nullptr, SDL_MapRGBA(minimapSurface_->format, 0, 0, 0, 0));
+            const int fx = contentX + hqX / num_x - static_cast<int>(flagBmp.nx);
+            const int fy = contentY + hqY / num_y - static_cast<int>(flagBmp.ny);
+            flagTex.Draw(Position(fx, fy));
+        }
 
-            // Draw minimap onto the temporary surface
-            map->drawMinimap(minimapSurface_.get());
+        // Player number
+        CFont::Draw(std::to_string(i + 1), Position(contentX + hqX / num_x, contentY + hqY / num_y), FontSize::Small,
+                    FontColor::MintGreen);
+    }
 
-            // Upload to texture and draw
-            minimapTex_.load(minimapSurface_.get());
-            minimapTex_.Draw(Rect(contentX, contentY, contentW, contentH));
+    // Draw the position arrow
+    {
+        const int arrowIdx = MAPPIC_ARROWCROSS_ORANGE;
+        const auto& arrowBmp = global::bmpArray[arrowIdx];
+        auto& arrowTex = getBmpTexture(arrowIdx);
+        if(arrowTex.isValid())
+        {
+            const auto& dispRect = map->getDisplayRect();
+            const int ax = contentX
+                           + (dispRect.left + static_cast<int>(dispRect.getSize().x) / 2) / triangleWidth / num_x
+                           - static_cast<int>(arrowBmp.nx);
+            const int ay = contentY
+                           + (dispRect.top + static_cast<int>(dispRect.getSize().y) / 2) / triangleHeight / num_y
+                           - static_cast<int>(arrowBmp.ny);
+            arrowTex.Draw(Position(ax, ay));
         }
     }
 }

CIO/CMinimapWindow.h

@@ -6,11 +6,11 @@
 
 #include "../Texture.h"
 #include "CWindow.h"
+#include <vector>
 
 class CMinimapWindow final : public CWindow
 {
-    /// Temporary SDL surface for minimap terrain overlay (kept until terrain is also OpenGL)
-    SdlSurface minimapSurface_;
+    std::vector<uint32_t> pixels_; ///< Pixel buffer for minimap terrain
     Texture minimapTex_;
 
     void Draw(Position parentOrigin) override;

CMap.cpp

@@ -1328,18 +1328,18 @@ static void getTriangleColor(const bobMAP& map, Uint8 rawTextureId, Sint16& r, S
     b = 128;
 }
 
-void CMap::drawMinimap(SDL_Surface* Window)
+void CMap::drawMinimap(std::vector<uint32_t>& pixels, int w, int h, int& num_x, int& num_y)
 {
-    // this variables are needed to reduce the size of minimap-windows of big maps
-    int num_x = (map->width > 256 ? map->width / 256 : 1);
-    int num_y = (map->height > 256 ? map->height / 256 : 1);
+    // Scale factors to keep minimap within a reasonable size
+    num_x = (map->width > 256 ? map->width / 256 : 1);
+    num_y = (map->height > 256 ? map->height / 256 : 1);
 
-    // make sure the minimap has the same proportions as the "real" map, so scale the same rate
+    // Keep aspect ratio uniform
     num_x = (num_x > num_y ? num_x : num_y);
-    num_y = (num_x > num_y ? num_x : num_y);
+    num_y = num_x;
 
-    // if (Window->w < map->width || Window->h < map->height)
-    // return;
+    // Ensure pixel buffer is the right size
+    pixels.assign(static_cast<size_t>(w) * h, 0);
 
     for(int y = 0; y < map->height; y++)
     {
@@ -1354,9 +1354,12 @@ void CMap::drawMinimap(SDL_Surface* Window)
             Sint16 r, g, b;
             getTriangleColor(*map, map->getVertex(x, y).rsuTexture, r, g, b);
 
-            Uint32* row = (Uint32*)Window->pixels + (y / num_y + 20) * Window->pitch / 4; //-V206
-            //+6 because of the left window frame
-            Uint32* pixel = row + x / num_x + 6;
+            const int py = y / num_y;
+            const int px = x / num_x;
+            if(py >= h || px >= w)
+                continue;
+
+            auto& pixel = pixels[static_cast<size_t>(py) * w + px];
 
             Sint32 vertexLighting = map->getVertex(x, y).i;
             r = ((r * vertexLighting) >> 16);
@@ -1365,32 +1368,10 @@ void CMap::drawMinimap(SDL_Surface* Window)
             const auto r8 = (Uint8)(r > 255 ? 255 : (r < 0 ? 0 : r));
             const auto g8 = (Uint8)(g > 255 ? 255 : (g < 0 ? 0 : g));
             const auto b8 = (Uint8)(b > 255 ? 255 : (b < 0 ? 0 : b));
-            *pixel = ((r8 << Window->format->Rshift) + (g8 << Window->format->Gshift) + (b8 << Window->format->Bshift));
-        }
-    }
-
-    // draw the player flags
-    for(int i = 0; i < MAXPLAYERS; i++)
-    {
-        if(PlayerHQx[i] != 0xFFFF && PlayerHQy[i] != 0xFFFF)
-        {
-            // draw flag
-            //%7 cause in the original game there are only 7 players and 7 different flags
-            CSurface::Draw(Window, global::bmpArray[FLAG_BLUE_DARK + i % 7].surface,
-                           6 + PlayerHQx[i] / num_x - global::bmpArray[FLAG_BLUE_DARK + i % 7].nx,
-                           20 + PlayerHQy[i] / num_y - global::bmpArray[FLAG_BLUE_DARK + i % 7].ny);
-            // write player number
-            CFont::writeText(Window, std::to_string(i + 1), 6 + PlayerHQx[i] / num_x, 20 + PlayerHQy[i] / num_y,
-                             FontSize::Small, FontColor::MintGreen);
+            // BGRA format: A<<24 | R<<16 | G<<8 | B
+            pixel = (0xFFu << 24) | (r8 << 16) | (g8 << 8) | b8;
         }
     }
-
-    // draw the arrow --> 6px is width of left window frame and 20px is the height of the upper window frame
-    CSurface::Draw(Window, global::bmpArray[MAPPIC_ARROWCROSS_ORANGE].surface,
-                   6 + (displayRect.left + displayRect.getSize().x / 2) / triangleWidth / num_x
-                     - global::bmpArray[MAPPIC_ARROWCROSS_ORANGE].nx,
-                   20 + (displayRect.top + displayRect.getSize().y / 2) / triangleHeight / num_y
-                     - global::bmpArray[MAPPIC_ARROWCROSS_ORANGE].ny);
 }
 
 void CMap::modifyVertex()

CMap.h

@@ -161,7 +161,11 @@ class CMap
     std::string getAuthor() const { return map->getAuthor(); }
     void setAuthor(const std::string& author) { map->setAuthor(author); }
 
-    void drawMinimap(SDL_Surface* Window);
+    /// Fill a pixel buffer with the minimap terrain view.
+    /// @param pixels  BGRA pixel buffer (w * h entries, 0xAARRGGBB layout).
+    /// @param w,h     Dimensions of the pixel buffer.
+    /// @param num_x,num_y  Output: scaling factors (map coords → pixel coords).
+    void drawMinimap(std::vector<uint32_t>& pixels, int w, int h, int& num_x, int& num_y);
     void render();
     // get and set some variables necessary for cursor behavior
     void setHexagonMode(bool HexagonMode)