make highlight colors configurable

nschimme · nschimme · commit 6f0ea10a1e51 · 2025-08-31T07:57:24.000-07:00
diff --git a/src/configuration/configuration.cpp b/src/configuration/configuration.cpp
@@ -934,13 +934,16 @@ void Configuration::NamedColorOptions::resetToDefaults()
     static const Color water{76, 216, 255};   // closest well-known color is "Malibu"
 
     BACKGROUND = background;
+    CONNECTION_NORMAL = Colors::white;
+    HIGHLIGHT_UNSAVED = Colors::cyan;
+    HIGHLIGHT_TEMPORARY = Colors::red;
+    HIGHLIGHT_NEEDS_SERVER_ID = Colors::yellow;
     INFOMARK_COMMENT = Colors::gray75;
     INFOMARK_HERB = Colors::green;
     INFOMARK_MOB = Colors::red;
     INFOMARK_OBJECT = Colors::yellow;
     INFOMARK_RIVER = water;
     INFOMARK_ROAD = road;
-    CONNECTION_NORMAL = Colors::white;
     ROOM_DARK = darkRoom;
     ROOM_NO_SUNDEATH = noSundeath;
     STREAM = water;
diff --git a/src/configuration/configuration.h b/src/configuration/configuration.h
@@ -181,13 +181,16 @@ class NODISCARD Configuration final
 
 #define XFOREACH_NAMED_COLOR_OPTIONS(X) \
     X(BACKGROUND, BACKGROUND_NAME) \
+    X(CONNECTION_NORMAL, CONNECTION_NORMAL_NAME) \
+    X(HIGHLIGHT_NEEDS_SERVER_ID, "highlight-needs-server-id") \
+    X(HIGHLIGHT_UNSAVED, "highlight-unsaved") \
+    X(HIGHLIGHT_TEMPORARY, "highlight-temporary") \
     X(INFOMARK_COMMENT, "infomark-comment") \
     X(INFOMARK_HERB, "infomark-herb") \
     X(INFOMARK_MOB, "infomark-mob") \
     X(INFOMARK_OBJECT, "infomark-object") \
     X(INFOMARK_RIVER, "infomark-river") \
     X(INFOMARK_ROAD, "infomark-road") \
-    X(CONNECTION_NORMAL, CONNECTION_NORMAL_NAME) \
     X(ROOM_DARK, ROOM_DARK_NAME) \
     X(ROOM_NO_SUNDEATH, ROOM_NO_SUNDEATH_NAME) \
     X(STREAM, "stream") \
diff --git a/src/display/Textures.cpp b/src/display/Textures.cpp
@@ -251,8 +251,7 @@ void MapCanvas::initTextures()
     textures.room_sel_move_bad = loadTexture(getPixmapFilenameRaw("room-sel-move-bad.png"));
     textures.room_sel_move_good = loadTexture(getPixmapFilenameRaw("room-sel-move-good.png"));
     // 256
-    textures.room_needs_update = loadTexture(getPixmapFilenameRaw("room-needs-update.png"));
-    textures.room_modified = loadTexture(getPixmapFilenameRaw("room-modified.png"));
+    textures.room_highlight = loadTexture(getPixmapFilenameRaw("room-highlight.png"));
 
     {
         textures.for_each([this](SharedMMTexture &pTex) -> void {
diff --git a/src/display/Textures.h b/src/display/Textures.h
@@ -128,8 +128,7 @@ using TextureArrayNESWUD = EnumIndexedArray<SharedMMTexture, ExitDirEnum, NUM_EX
     X(SharedMMTexture, room_sel_distant) \
     X(SharedMMTexture, room_sel_move_bad) \
     X(SharedMMTexture, room_sel_move_good) \
-    X(SharedMMTexture, room_needs_update) \
-    X(SharedMMTexture, room_modified)
+    X(SharedMMTexture, room_highlight)
 
 struct NODISCARD MapCanvasTextures final
 {
diff --git a/src/display/mapcanvas.h b/src/display/mapcanvas.h
@@ -73,21 +73,24 @@ class NODISCARD_QOBJECT MapCanvas final : public QOpenGLWidget,
     struct NODISCARD Diff final
     {
         struct NODISCARD MaybeDataOrMesh final
-            : public std::variant<std::monostate, TexVertVector, UniqueMesh>
+            : public std::variant<std::monostate, ColoredTexVertVector, UniqueMesh>
         {
         public:
-            using base = std::variant<std::monostate, TexVertVector, UniqueMesh>;
+            using base = std::variant<std::monostate, ColoredTexVertVector, UniqueMesh>;
             using base::base;
 
         public:
             NODISCARD bool empty() const { return std::holds_alternative<std::monostate>(*this); }
-            NODISCARD bool hasData() const { return std::holds_alternative<TexVertVector>(*this); }
+            NODISCARD bool hasData() const
+            {
+                return std::holds_alternative<ColoredTexVertVector>(*this);
+            }
             NODISCARD bool hasMesh() const { return std::holds_alternative<UniqueMesh>(*this); }
 
         public:
-            NODISCARD const TexVertVector &getData() const
+            NODISCARD const ColoredTexVertVector &getData() const
             {
-                return std::get<TexVertVector>(*this);
+                return std::get<ColoredTexVertVector>(*this);
             }
             NODISCARD const UniqueMesh &getMesh() const { return std::get<UniqueMesh>(*this); }
 
@@ -99,7 +102,7 @@ class NODISCARD_QOBJECT MapCanvas final : public QOpenGLWidget,
                 }
 
                 if (hasData()) {
-                    *this = gl.createTexturedQuadBatch(getData(), texId);
+                    *this = gl.createColoredTexturedQuadBatch(getData(), texId);
                     assert(hasMesh());
                     // REVISIT: rendering immediately after uploading the mesh may lag,
                     // so consider delaying until the data is already on the GPU.
@@ -110,17 +113,15 @@ class NODISCARD_QOBJECT MapCanvas final : public QOpenGLWidget,
                     return;
                 }
                 auto &mesh = getMesh();
-                mesh.render(
-                    GLRenderState().withColor(Colors::white).withBlend(BlendModeEnum::TRANSPARENCY));
+                mesh.render(GLRenderState().withBlend(BlendModeEnum::TRANSPARENCY));
             }
         };
 
         struct NODISCARD HighlightDiff final
         {
             Map saved;
             Map current;
-            MaybeDataOrMesh needsUpdate;
-            MaybeDataOrMesh modified;
+            MaybeDataOrMesh highlights;
         };
 
         std::optional<std::future<HighlightDiff>> futureHighlight;
diff --git a/src/display/mapcanvas_gl.cpp b/src/display/mapcanvas_gl.cpp
@@ -253,14 +253,14 @@ void MapCanvas::initializeGL()
 
     setConfig().canvas.showUnsavedChanges.registerChangeCallback(m_lifetime, [this]() {
         if (getConfig().canvas.showUnsavedChanges.get() && m_diff.highlight.has_value()
-            && m_diff.highlight->modified.empty()) {
+            && m_diff.highlight->highlights.empty()) {
             this->forceUpdateMeshes();
         }
     });
 
     setConfig().canvas.showMissingMapId.registerChangeCallback(m_lifetime, [this]() {
         if (getConfig().canvas.showMissingMapId.get() && m_diff.highlight.has_value()
-            && m_diff.highlight->needsUpdate.empty()) {
+            && m_diff.highlight->highlights.empty()) {
             this->forceUpdateMeshes();
         }
     });
@@ -465,7 +465,7 @@ void MapCanvas::setViewportAndMvp(int width, int height)
 
 void MapCanvas::resizeGL(int width, int height)
 {
-    if (m_textures.room_modified == nullptr) {
+    if (m_textures.room_highlight == nullptr) {
         // resizeGL called but initializeGL was not called yet
         return;
     }
@@ -670,13 +670,20 @@ void MapCanvas::Diff::maybeAsyncUpdate(const Map &saved, const Map &current)
         return;
     }
 
-    const bool showNeedsServerId = getConfig().canvas.showMissingMapId.get();
-    const bool showChanged = getConfig().canvas.showUnsavedChanges.get();
+    const auto &config = getConfig();
+    const auto &canvas = config.canvas;
+    const bool showNeedsServerId = canvas.showMissingMapId.get();
+    const bool showChanged = canvas.showUnsavedChanges.get();
+    const auto colorSettings = config.colorSettings.clone();
 
     diff.futureHighlight = std::async(
         std::launch::async,
-        [saved, current, showNeedsServerId, showChanged]() -> Diff::HighlightDiff {
-            DECL_TIMER(t2, "[async] actuallyPaintGL: highlight differences and needs update");
+        [saved, current, showNeedsServerId, showChanged, colorSettings]() -> Diff::HighlightDiff {
+            DECL_TIMER(t2,
+                       "[async] actuallyPaintGL: highlight changes, temporary, and needs update");
+
+            const auto &colors = deref(colorSettings);
+
             // 3-2
             // |/|
             // 0-1
@@ -687,56 +694,49 @@ void MapCanvas::Diff::maybeAsyncUpdate(const Map &saved, const Map &current)
                 glm::vec3{0, 1, 0},
             };
 
-            // REVISIT: Just send the position and convert from point to quad in a shader?
-            auto getChanged = [&saved, &current, showChanged]() -> Diff::MaybeDataOrMesh {
-                if (!showChanged) {
+            auto getHighlights = [&saved, &current, showChanged, showNeedsServerId, &colors]()
+                -> Diff::MaybeDataOrMesh {
+                if (!showChanged && !showNeedsServerId) {
                     return Diff::MaybeDataOrMesh{};
                 }
-                DECL_TIMER(t3, "[async] actuallyPaintGL: compute differences");
-                TexVertVector changed;
-                auto drawQuad = [&changed](const RawRoom &room) {
+
+                DECL_TIMER(t3, "[async] actuallyPaintGL: compute highlights");
+                ColoredTexVertVector highlights;
+                auto drawQuad = [&highlights](const RawRoom &room, const XNamedColor &color) {
                     const auto &pos = room.getPosition().to_vec3();
                     for (auto &corner : corners) {
-                        changed.emplace_back(corner, pos + corner);
+                        highlights.emplace_back(color.getColor(), corner, pos + corner);
                     }
                 };
 
-                ProgressCounter dummyPc;
-                Map::foreachChangedRoom(dummyPc, saved, current, drawQuad);
-                if (changed.empty()) {
-                    return Diff::MaybeDataOrMesh{};
+                // Handle rooms needing a server ID or that are temporary
+                if (showNeedsServerId) {
+                    current.getRooms().for_each([&](auto id) {
+                        if (auto h = current.getRoomHandle(id)) {
+                            if (h.isTemporary()) {
+                                drawQuad(h.getRaw(), colors.HIGHLIGHT_TEMPORARY);
+                            } else if (h.getServerId() == INVALID_SERVER_ROOMID) {
+                                drawQuad(h.getRaw(), colors.HIGHLIGHT_NEEDS_SERVER_ID);
+                            }
+                        }
+                    });
                 }
 
-                return Diff::MaybeDataOrMesh{std::move(changed)};
-            };
-
-            auto getNeedsUpdate = [&current, showNeedsServerId]() -> Diff::MaybeDataOrMesh {
-                if (!showNeedsServerId) {
-                    return MapCanvas::Diff::MaybeDataOrMesh{};
+                // Handle changed rooms
+                if (showChanged) {
+                    ProgressCounter dummyPc;
+                    Map::foreachChangedRoom(dummyPc, saved, current, [&](const RawRoom &room) {
+                        drawQuad(room, colors.HIGHLIGHT_UNSAVED);
+                    });
                 }
-                DECL_TIMER(t3, "[async] actuallyPaintGL: compute needs update");
 
-                TexVertVector needsUpdate;
-                auto drawQuad = [&needsUpdate](const RoomHandle &h) {
-                    const auto &pos = h.getPosition().to_vec3();
-                    for (auto &corner : corners) {
-                        needsUpdate.emplace_back(corner, pos + corner);
-                    }
-                };
-                current.getRooms().for_each([&current, &drawQuad](auto id) {
-                    if (auto h = current.getRoomHandle(id)) {
-                        if (h.getServerId() == INVALID_SERVER_ROOMID) {
-                            drawQuad(h);
-                        }
-                    }
-                });
-                if (needsUpdate.empty()) {
+                if (highlights.empty()) {
                     return Diff::MaybeDataOrMesh{};
                 }
-                return Diff::MaybeDataOrMesh{std::move(needsUpdate)};
+                return Diff::MaybeDataOrMesh{std::move(highlights)};
             };
 
-            return Diff::HighlightDiff{saved, current, getNeedsUpdate(), getChanged()};
+            return Diff::HighlightDiff{saved, current, getHighlights()};
         });
 }
 
@@ -754,13 +754,8 @@ void MapCanvas::paintDifferences()
     auto &highlight = deref(diff.highlight);
     auto &gl = getOpenGL();
 
-    if (getConfig().canvas.showMissingMapId.get()) {
-        if (auto &needsUpdate = highlight.needsUpdate; !needsUpdate.empty()) {
-            needsUpdate.render(gl, m_textures.room_needs_update->getId());
-        }
-    }
-    if (auto &modified = highlight.modified; !modified.empty()) {
-        modified.render(gl, m_textures.room_modified->getId());
+    if (auto &highlights = highlight.highlights; !highlights.empty()) {
+        highlights.render(gl, m_textures.room_highlight->getId());
     }
 }
 
diff --git a/src/opengl/OpenGLTypes.h b/src/opengl/OpenGLTypes.h
@@ -48,6 +48,8 @@ struct NODISCARD ColoredTexVert final
     {}
 };
 
+using ColoredTexVertVector = std::vector<ColoredTexVert>;
+
 struct NODISCARD ColorVert final
 {
     Color color;
diff --git a/src/resources/mmapper2.qrc b/src/resources/mmapper2.qrc
@@ -158,12 +158,11 @@
         <file>pixmaps/road-s.png</file>
         <file>pixmaps/road-sw.png</file>
         <file>pixmaps/road-w.png</file>
+        <file>pixmaps/room-highlight.png</file>
         <file>pixmaps/room-sel-distant.png</file>
         <file>pixmaps/room-sel-move-bad.png</file>
         <file>pixmaps/room-sel-move-good.png</file>
         <file>pixmaps/room-sel.png</file>
-        <file>pixmaps/room-modified.png</file>
-        <file>pixmaps/room-needs-update.png</file>
         <file>pixmaps/stream-in-down.png</file>
         <file>pixmaps/stream-in-east.png</file>
         <file>pixmaps/stream-in-north.png</file>
diff --git a/src/resources/pixmaps/room-highlight.png b/src/resources/pixmaps/room-highlight.png
diff --git a/src/resources/pixmaps/room-modified.png b/src/resources/pixmaps/room-modified.png
diff --git a/src/resources/pixmaps/room-needs-update.png b/src/resources/pixmaps/room-needs-update.png

Original file line number	Diff line number	Diff line change
`@@ -251,8 +251,7 @@ void MapCanvas::initTextures()`
`251`	`251`	`textures.room_sel_move_bad = loadTexture(getPixmapFilenameRaw("room-sel-move-bad.png"));`
`252`	`252`	`textures.room_sel_move_good = loadTexture(getPixmapFilenameRaw("room-sel-move-good.png"));`
`253`	`253`	`// 256`
`254`		`- textures.room_needs_update = loadTexture(getPixmapFilenameRaw("room-needs-update.png"));`
`255`		`- textures.room_modified = loadTexture(getPixmapFilenameRaw("room-modified.png"));`
	`254`	`+ textures.room_highlight = loadTexture(getPixmapFilenameRaw("room-highlight.png"));`
`256`	`255`
`257`	`256`	`{`
`258`	`257`	`textures.for_each([this](SharedMMTexture &pTex) -> void {`
Original file line number	Diff line number	Diff line change
`@@ -128,8 +128,7 @@ using TextureArrayNESWUD = EnumIndexedArray<SharedMMTexture, ExitDirEnum, NUM_EX`
`128`	`128`	`X(SharedMMTexture, room_sel_distant) \`
`129`	`129`	`X(SharedMMTexture, room_sel_move_bad) \`
`130`	`130`	`X(SharedMMTexture, room_sel_move_good) \`
`131`		`- X(SharedMMTexture, room_needs_update) \`
`132`		`- X(SharedMMTexture, room_modified)`
	`131`	`+ X(SharedMMTexture, room_highlight)`
`133`	`132`
`134`	`133`	`struct NODISCARD MapCanvasTextures final`
`135`	`134`	`{`
Original file line number	Diff line number	Diff line change
`@@ -48,6 +48,8 @@ struct NODISCARD ColoredTexVert final`
`48`	`48`	`{}`
`49`	`49`	`};`
`50`	`50`
	`51`	`+using ColoredTexVertVector = std::vector<ColoredTexVert>;`
	`52`	`+`
`51`	`53`	`struct NODISCARD ColorVert final`
`52`	`54`	`{`
`53`	`55`	`Color color;`