diff --git a/.ai/memory/architecture/activex.md b/.ai/memory/architecture/activex.md index d41661c..28a19de 100644 --- a/.ai/memory/architecture/activex.md +++ b/.ai/memory/architecture/activex.md @@ -41,6 +41,13 @@ replacement initialization must retain its failure state for the 60-draw retry delay. A size change bypasses the delay. See `OpenGlVectorLayerRenderer::Draw` and the renderer/control regression tests. +The OpenGL lazy fill-mesh cache belongs to the renderer and is shared with +temporary renderers. It is keyed by `LayerId` and the immutable scene identity: +reordering, hiding, viewport changes, and backend selection preserve entries, +while a changed scene for one layer invalidates only that entry. The coordinator +prunes removed IDs before every backend choice, and explicit layer or scene +invalidation releases the retained CPU mesh storage. + Core objects are not thread-safe by default. The control serializes their use. ActiveX-specific implementation units are also compiled into `MapWinGIS.ActiveX.Impl.lib`, allowing native tests to exercise them without @@ -67,10 +74,11 @@ The control exposes a deliberately small v6 automation API. It does not expose the broad MapWinGIS 5 map, layer, shape, event, or editing surface. The current render scene is built in source coordinates, without reprojection; backend support differs: GDI draws the original rings with an alternate fill rule, -while OpenGL fill draws require explicitly prepared meshes. Normal Core scene -creation is mesh-free; fill operations without usable meshes fall back to -GDI, which fills the original rings. The OpenGL renderer also has an -outline mode that draws those rings without triangulation. +while OpenGL fill draws require triangle meshes. Normal Core scene +creation is mesh-free; OpenGL fills prepare missing meshes lazily and fall +back to GDI if preparation fails or an explicitly prepared mesh is unusable. +GDI fills the original rings. The OpenGL renderer also has an outline mode +that draws those rings without triangulation. Consult the current implementation and architecture documentation before assuming a capability or compatibility guarantee. diff --git a/.github/plans/Vector-Rendering-Performance-Improvement.md b/.github/plans/Vector-Rendering-Performance-Improvement.md index bc9ef5b..d77356e 100644 --- a/.github/plans/Vector-Rendering-Performance-Improvement.md +++ b/.github/plans/Vector-Rendering-Performance-Improvement.md @@ -18,7 +18,10 @@ Copilot: Update this checklist as each phase is implemented. Only mark a phase c - Explicitly prepared meshes remain preferred; outline and GDI paths continue to use source rings without requiring fill meshes. - Triangulation failures, including exceptions from GDAL logging callbacks, return to the coordinator for GDI fallback without preventing outline rendering. - Limitation: triangulation remains synchronous, and broader cache ownership, memory limits, and invalidation rules remain Phase 4 work. -- [ ] **Phase 4 – Add intelligent caching and invalidation** (PR 4) +- [x] **Phase 4 – Add intelligent caching and invalidation** (PR 4) + - OpenGL lazy fill meshes are cached per stable layer ID and immutable scene identity, surviving viewport changes, layer reordering, temporary draws, visibility changes, and backend selection. + - Scene replacement, explicit per-layer invalidation, removed-layer pruning, and clear-all invalidation release only the affected generated mesh storage; retained mesh bytes are tracked for tests. + - Limitation: no cache-size limit or eviction policy was added because measurements did not establish that the additional complexity is justified. - [ ] **Phase 5 – Introduce viewport-aware geometry processing** (PR 5) - [ ] **Phase 6 – Optimize OpenGL rendering and data transfer** (PR 6) - [ ] **Phase 7 – Testing and regression prevention** (PR 7) diff --git a/README.md b/README.md index 5fc0b0e..6194944 100644 --- a/README.md +++ b/README.md @@ -41,7 +41,9 @@ release the loaded datasets before switching or refreshing them. Core stores polygon coordinates in flat buffers and caches prepared geometry per map layer. Visibility changes reuse that geometry without rereading datasets or triangulating polygons again. OpenGL generates missing fill -meshes on the first fill draw and reuses them for that render scene. +meshes on the first fill draw and caches them per stable map layer. Viewport +changes, backend selection, layer reordering, and temporary draws reuse valid +entries; changed or removed layers release or replace only their own meshes. ## Build and test diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 03c0929..15f7a05 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -474,6 +474,11 @@ cache directly. Layer scenes are immutable and shared through `std::shared_ptr`, so assembling the map snapshot shares cached coordinates and meshes instead of copying them; peak memory stays at one copy of each layer's geometry. +OpenGL's lazily generated fill meshes have a second, backend-owned cache keyed +by stable `LayerId` and the immutable scene identity. Reordering, hiding, +redrawing, viewport changes, and backend selection retain valid entries. +Replacing one layer scene invalidates only that layer's entry; removed layers +and explicit invalidation release their generated mesh storage. When a driver cannot provide a fast extent, scene preparation computes bounds during the geometry traversal. It caches those bounds on the vector layer, so a later map fit does not scan the layer again. diff --git a/src/MapWinGIS.ActiveX/OpenGlVectorLayerRenderer.cpp b/src/MapWinGIS.ActiveX/OpenGlVectorLayerRenderer.cpp index ce4a322..3c53d60 100644 --- a/src/MapWinGIS.ActiveX/OpenGlVectorLayerRenderer.cpp +++ b/src/MapWinGIS.ActiveX/OpenGlVectorLayerRenderer.cpp @@ -23,7 +23,9 @@ #include #include #include +#include #include +#include #include #include @@ -173,6 +175,24 @@ namespace mwg::activex return true; } + [[nodiscard]] bool AreFillMeshesUsable( + const std::span> fillMeshes, + const std::size_t polygonCount) noexcept + { + if (fillMeshes.size() != polygonCount) + { + return false; + } + for (const std::optional& mesh : fillMeshes) + { + if (!mesh.has_value() || !IsMeshUsable(*mesh)) + { + return false; + } + } + return true; + } + /// Returns true when the scene has finite ring coordinates and, in /// fill mode, one usable mesh per polygon. [[nodiscard]] bool IsSupported( @@ -350,11 +370,13 @@ namespace mwg::activex { std::weak_ptr scene; std::vector> generatedMeshes; + bool failed = false; + std::uint64_t preparationToken = 0; }; - std::vector layers; - bool failed = false; + std::map layers; std::uint64_t generation = 0; + std::uint64_t nextPreparationToken = 0; }; bool OpenGlVectorLayerRenderer::IsSceneSupported( @@ -695,110 +717,107 @@ namespace mwg::activex } HRESULT OpenGlVectorLayerRenderer::PrepareFillMeshes( - const rendering::MapRenderScene& scene) noexcept + const rendering::MapRenderScene& scene, + const bool pruneCache) noexcept { - if (_fillMeshCache != nullptr && - _fillMeshCache->layers.size() == scene.layers.size()) + if (pruneCache && !PruneFillMeshCache(scene)) { - bool matches = true; - for (std::size_t index = 0; index < scene.layers.size(); ++index) - { - if (_fillMeshCache->layers[index].scene.lock() != - scene.layers[index].scene) - { - matches = false; - break; - } - } - if (matches) - { - if (_fillMeshCache->failed) - { - _lastFailureReason = - L"The OpenGL backend could not triangulate a polygon for fill " - L"rendering; this frame was rendered with GDI."; - return S_FALSE; - } - return S_OK; - } + return S_FALSE; } + std::shared_ptr cache; try { if (_fillMeshCache == nullptr) { _fillMeshCache = std::make_shared(); } - FillMeshCache prepared; - prepared.layers.reserve(scene.layers.size()); + cache = _fillMeshCache; for (const rendering::LayerRenderScene& layer : scene.layers) { - FillMeshCache::Layer cachedLayer; - cachedLayer.scene = layer.scene; - if (!prepared.failed && - layer.scene != nullptr && - layer.scene->fillMeshes.empty()) + if (layer.scene == nullptr || !layer.scene->fillMeshes.empty()) { - cachedLayer.generatedMeshes.reserve(layer.scene->polygons.size()); - for (std::size_t index = 0; - index < layer.scene->polygons.size(); - ++index) + continue; + } + + const auto cached = cache->layers.find(layer.layerId); + if (cached != cache->layers.end()) + { + continue; + } + + auto [pending, inserted] = cache->layers.try_emplace(layer.layerId); + if (!inserted) + { + continue; + } + const std::uint64_t cacheGeneration = cache->generation; + const std::uint64_t preparationToken = ++cache->nextPreparationToken; + pending->second.scene = layer.scene; + pending->second.preparationToken = preparationToken; + + std::vector> generatedMeshes; + generatedMeshes.reserve(layer.scene->polygons.size()); + bool failed = false; + for (std::size_t index = 0; + index < layer.scene->polygons.size(); + ++index) + { + try { - try + rendering::TriangleMesh mesh = + rendering::TriangulatePolygon(layer.scene->polygons[index]); + if (!IsMeshUsable(mesh)) { - rendering::TriangleMesh mesh = - rendering::TriangulatePolygon(layer.scene->polygons[index]); - if (!IsMeshUsable(mesh)) - { - prepared.failed = true; - cachedLayer.generatedMeshes.resize( - layer.scene->polygons.size()); - break; - } - cachedLayer.generatedMeshes.push_back(std::move(mesh)); - } - catch (const mwg::CoreError&) - { - prepared.failed = true; - cachedLayer.generatedMeshes.resize( - layer.scene->polygons.size()); - break; - } - catch (const std::bad_alloc&) - { - throw; - } - catch (const std::length_error&) - { - throw; - } - catch (const std::exception&) - { - prepared.failed = true; - cachedLayer.generatedMeshes.resize( - layer.scene->polygons.size()); - break; - } - catch (...) - { - prepared.failed = true; - cachedLayer.generatedMeshes.resize( - layer.scene->polygons.size()); + failed = true; break; } + generatedMeshes.push_back(std::move(mesh)); + } + catch (const mwg::CoreError&) + { + failed = true; + break; + } + catch (const std::bad_alloc&) + { + throw; + } + catch (const std::length_error&) + { + throw; + } + catch (const std::exception&) + { + failed = true; + break; + } + catch (...) + { + failed = true; + break; } } - prepared.layers.push_back(std::move(cachedLayer)); - } - if (prepared.failed) - { - for (FillMeshCache::Layer& layer : prepared.layers) + pending = cache->layers.find(layer.layerId); + if (_fillMeshCache != cache || + cache->generation != cacheGeneration || + pending == cache->layers.end() || + pending->second.preparationToken != preparationToken || + pending->second.scene.lock() != layer.scene) + { + _lastFailureReason = + L"The OpenGL fill-mesh cache changed during triangulation; " + L"this frame was rendered with GDI."; + return S_FALSE; + } + if (failed) { - layer.generatedMeshes.clear(); + std::vector>() + .swap(generatedMeshes); } + pending->second.generatedMeshes = std::move(generatedMeshes); + pending->second.failed = failed; } - _fillMeshCache->layers = std::move(prepared.layers); - _fillMeshCache->failed = prepared.failed; } catch (const std::bad_alloc&) { @@ -813,27 +832,121 @@ namespace mwg::activex return S_FALSE; } - if (_fillMeshCache->failed) + for (const rendering::LayerRenderScene& layer : scene.layers) { - _lastFailureReason = - L"The OpenGL backend could not triangulate a polygon for fill " - L"rendering; this frame was rendered with GDI."; - return S_FALSE; + if (layer.scene == nullptr || !layer.scene->fillMeshes.empty()) + { + continue; + } + const auto cached = cache->layers.find(layer.layerId); + if (cached == cache->layers.end() || + cached->second.failed || + cached->second.scene.lock() != layer.scene || + !AreFillMeshesUsable( + cached->second.generatedMeshes, + layer.scene->polygons.size())) + { + _lastFailureReason = + L"The OpenGL backend could not triangulate a polygon for fill " + L"rendering; this frame was rendered with GDI."; + return S_FALSE; + } } return S_OK; } std::span> OpenGlVectorLayerRenderer::GetFillMeshes( - const std::size_t layerIndex, + const LayerId layerId, const rendering::VectorRenderScene& scene) const noexcept { - const FillMeshCache::Layer& cached = _fillMeshCache->layers[layerIndex]; if (!scene.fillMeshes.empty()) { - return scene.fillMeshes; + return AreFillMeshesUsable(scene.fillMeshes, scene.polygons.size()) + ? std::span>(scene.fillMeshes) + : std::span>(); + } + if (_fillMeshCache == nullptr) + { + return {}; + } + const auto cached = _fillMeshCache->layers.find(layerId); + if (cached == _fillMeshCache->layers.end() || + cached->second.scene.lock().get() != &scene || + cached->second.failed || + !AreFillMeshesUsable( + cached->second.generatedMeshes, + scene.polygons.size())) + { + return {}; } - return cached.generatedMeshes; + return cached->second.generatedMeshes; + } + + bool OpenGlVectorLayerRenderer::PruneFillMeshCache( + const rendering::MapRenderScene& scene) noexcept + { + if (_fillMeshCache == nullptr) + { + return true; + } + + try + { + std::map< + LayerId, + std::shared_ptr> drawableLayers; + std::set hiddenLayers; + for (const rendering::LayerRenderScene& layer : scene.layers) + { + drawableLayers.insert_or_assign(layer.layerId, layer.scene); + } + for (const rendering::SkippedLayer& layer : scene.skippedLayers) + { + if (layer.reason == rendering::LayerSkipReason::Hidden) + { + hiddenLayers.insert(layer.layerId); + } + } + + for (auto cached = _fillMeshCache->layers.begin(); + cached != _fillMeshCache->layers.end();) + { + const auto drawable = drawableLayers.find(cached->first); + if (drawable != drawableLayers.end()) + { + if (!cached->second.scene.expired() && + cached->second.scene.lock() == drawable->second) + { + ++cached; + continue; + } + cached = _fillMeshCache->layers.erase(cached); + continue; + } + + if (hiddenLayers.contains(cached->first) && + !cached->second.scene.expired()) + { + ++cached; + continue; + } + cached = _fillMeshCache->layers.erase(cached); + } + } + catch (const std::bad_alloc&) + { + _lastFailureReason = + L"The OpenGL backend could not allocate its fill-mesh cache index."; + return false; + } + catch (const std::length_error&) + { + _lastFailureReason = + L"The OpenGL backend could not represent its fill-mesh cache index."; + return false; + } + return true; } void OpenGlVectorLayerRenderer::ClearFillMeshCache() noexcept @@ -843,10 +956,19 @@ namespace mwg::activex return; } _fillMeshCache->layers.clear(); - _fillMeshCache->failed = false; ++_fillMeshCache->generation; } + void OpenGlVectorLayerRenderer::ClearLayerFillMeshCache( + const LayerId layerId) noexcept + { + if (_fillMeshCache == nullptr) + { + return; + } + (void)_fillMeshCache->layers.erase(layerId); + } + std::size_t OpenGlVectorLayerRenderer::FillMeshCacheSize() const noexcept { return _fillMeshCache == nullptr ? 0U : _fillMeshCache->layers.size(); @@ -859,9 +981,36 @@ namespace mwg::activex return 0U; } std::size_t storage = 0; - for (const FillMeshCache::Layer& layer : _fillMeshCache->layers) + for (const auto& cached : _fillMeshCache->layers) { - storage += layer.generatedMeshes.size(); + storage += cached.second.generatedMeshes.size(); + } + return storage; + } + + std::size_t + OpenGlVectorLayerRenderer::CachedGeneratedMeshStorageBytes() const noexcept + { + if (_fillMeshCache == nullptr) + { + return 0U; + } + + std::size_t storage = 0; + for (const auto& cached : _fillMeshCache->layers) + { + const FillMeshCache::Layer& layer = cached.second; + storage += layer.generatedMeshes.capacity() * + sizeof(std::optional); + for (const std::optional& mesh : + layer.generatedMeshes) + { + if (mesh.has_value()) + { + storage += mesh->vertices.capacity() * sizeof(rendering::Point); + storage += mesh->indices.capacity() * sizeof(std::uint32_t); + } + } } return storage; } @@ -931,8 +1080,16 @@ namespace mwg::activex const rendering::LayerRenderScene& layer = scene.layers[index]; const std::span> fillMeshes = renderMode == VectorRenderMode::Fill - ? GetFillMeshes(index, *layer.scene) + ? GetFillMeshes(layer.layerId, *layer.scene) : std::span>(); + if (renderMode == VectorRenderMode::Fill && + !AreFillMeshesUsable(fillMeshes, layer.scene->polygons.size())) + { + _lastFailureReason = + L"The OpenGL fill-mesh cache no longer matches the scene; " + L"this frame was rendered with GDI."; + return S_FALSE; + } const HRESULT layerResult = DrawLayer( *layer.scene, @@ -1107,6 +1264,10 @@ namespace mwg::activex L"The OpenGL backend could not represent its render-scene snapshot."; return S_FALSE; } + if (!PruneFillMeshCache(stableScene)) + { + return S_FALSE; + } const diagnostics::PerformanceScope frameScope( diagnostics::PerformanceOperation::FrameRender); _lastFailureReason = L"OpenGL did not render this frame."; @@ -1174,16 +1335,9 @@ namespace mwg::activex return S_FALSE; } - const std::uint64_t cacheGeneration = - _fillMeshCache == nullptr ? 0U : _fillMeshCache->generation; if (renderMode == VectorRenderMode::Fill && - PrepareFillMeshes(stableScene) != S_OK) + PrepareFillMeshes(stableScene, false) != S_OK) { - if (_fillMeshCache != nullptr && - _fillMeshCache->generation != cacheGeneration) - { - ClearFillMeshCache(); - } return S_FALSE; } @@ -1191,21 +1345,11 @@ namespace mwg::activex RenderScene(stableScene, viewport, target, renderMode); if (FAILED(renderResult) || renderResult == S_FALSE) { - if (_fillMeshCache != nullptr && - _fillMeshCache->generation != cacheGeneration) - { - ClearFillMeshCache(); - } return renderResult; } const HRESULT copyResult = CopyToDeviceContext(deviceContext, bounds, target); - if (_fillMeshCache != nullptr && - _fillMeshCache->generation != cacheGeneration) - { - ClearFillMeshCache(); - } return copyResult; } } diff --git a/src/MapWinGIS.ActiveX/OpenGlVectorLayerRenderer.h b/src/MapWinGIS.ActiveX/OpenGlVectorLayerRenderer.h index 279d752..7e1848f 100644 --- a/src/MapWinGIS.ActiveX/OpenGlVectorLayerRenderer.h +++ b/src/MapWinGIS.ActiveX/OpenGlVectorLayerRenderer.h @@ -123,14 +123,19 @@ namespace mwg::activex VectorRenderMode renderMode) noexcept; [[nodiscard]] bool EnsureStaging(std::size_t stagingBytes) noexcept; [[nodiscard]] HRESULT PrepareFillMeshes( - const rendering::MapRenderScene& scene) noexcept; + const rendering::MapRenderScene& scene, + bool pruneCache = true) noexcept; [[nodiscard]] std::span> GetFillMeshes( - std::size_t layerIndex, + LayerId layerId, const rendering::VectorRenderScene& scene) const noexcept; + [[nodiscard]] bool PruneFillMeshCache( + const rendering::MapRenderScene& scene) noexcept; void ClearFillMeshCache() noexcept; + void ClearLayerFillMeshCache(LayerId layerId) noexcept; [[nodiscard]] std::size_t FillMeshCacheSize() const noexcept; [[nodiscard]] std::size_t CachedGeneratedMeshStorage() const noexcept; + [[nodiscard]] std::size_t CachedGeneratedMeshStorageBytes() const noexcept; [[nodiscard]] HRESULT RenderScene( const rendering::MapRenderScene& scene, const Viewport& viewport, diff --git a/src/MapWinGIS.ActiveX/VectorLayerRenderer.cpp b/src/MapWinGIS.ActiveX/VectorLayerRenderer.cpp index da27363..cebedbf 100644 --- a/src/MapWinGIS.ActiveX/VectorLayerRenderer.cpp +++ b/src/MapWinGIS.ActiveX/VectorLayerRenderer.cpp @@ -66,7 +66,14 @@ namespace mwg::activex } else { - _diagnostic = L"GDI was selected by the rendering preference."; + if (!_openGlRenderer.PruneFillMeshCache(stableScene)) + { + _diagnostic = _openGlRenderer.GetLastFailureReason(); + } + else + { + _diagnostic = L"GDI was selected by the rendering preference."; + } } const HRESULT gdiResult = diff --git a/src/MapWinGIS.ActiveX/VectorLayerRenderer.h b/src/MapWinGIS.ActiveX/VectorLayerRenderer.h index 15b2da3..1a8f081 100644 --- a/src/MapWinGIS.ActiveX/VectorLayerRenderer.h +++ b/src/MapWinGIS.ActiveX/VectorLayerRenderer.h @@ -74,6 +74,11 @@ namespace mwg::activex _openGlRenderer.ClearFillMeshCache(); } + void InvalidateLayerSceneCache(const LayerId layerId) noexcept + { + _openGlRenderer.ClearLayerFillMeshCache(layerId); + } + private: friend class testing::MapWinGISControlTestAccess; diff --git a/tests/MapWinGIS.ActiveX.Tests/OpenGlVectorLayerRendererTestAccess.h b/tests/MapWinGIS.ActiveX.Tests/OpenGlVectorLayerRendererTestAccess.h index a15f799..d30c186 100644 --- a/tests/MapWinGIS.ActiveX.Tests/OpenGlVectorLayerRendererTestAccess.h +++ b/tests/MapWinGIS.ActiveX.Tests/OpenGlVectorLayerRendererTestAccess.h @@ -74,5 +74,17 @@ namespace mwg::activex::testing { return renderer.CachedGeneratedMeshStorage(); } + + [[nodiscard]] static std::size_t CachedGeneratedMeshStorageBytes( + const OpenGlVectorLayerRenderer& renderer) noexcept + { + return renderer.CachedGeneratedMeshStorageBytes(); + } + + static void InvalidateLayerSceneCache( + OpenGlVectorLayerRenderer& renderer, const LayerId layerId) noexcept + { + renderer.ClearLayerFillMeshCache(layerId); + } }; } diff --git a/tests/MapWinGIS.ActiveX.Tests/VectorLayerRendererTests.cpp b/tests/MapWinGIS.ActiveX.Tests/VectorLayerRendererTests.cpp index 40b8f98..b306cad 100644 --- a/tests/MapWinGIS.ActiveX.Tests/VectorLayerRendererTests.cpp +++ b/tests/MapWinGIS.ActiveX.Tests/VectorLayerRendererTests.cpp @@ -458,6 +458,114 @@ TEST(VectorLayerRenderer, OpenGlLazilyTriangulatesAndReusesFillMeshes) EXPECT_TRUE(scene.layers.front().scene->fillMeshes.empty()); } +TEST(VectorLayerRenderer, OpenGlCachesLazyMeshesPerLayerAcrossSceneChanges) +{ + using Access = mwg::activex::testing::OpenGlVectorLayerRendererTestAccess; + mwg::rendering::MapRenderScene scene = MakeMapScene({ + MakeRectangleLayer({0.0, 0.0, 10.0, 10.0}), + MakeRectangleLayer({20.0, 0.0, 30.0, 10.0})}); + Edit(scene.layers[0]).fillMeshes.clear(); + Edit(scene.layers[1]).fillMeshes.clear(); + const mwg::LayerId firstId = scene.layers[0].layerId; + const mwg::LayerId secondId = scene.layers[1].layerId; + PerformanceCapture diagnostics; + mwg::activex::OpenGlVectorLayerRenderer renderer; + + ASSERT_EQ(Access::PrepareFillMeshes(renderer, scene), S_OK); + EXPECT_EQ(Access::FillMeshCacheSize(renderer), 2U); + const std::size_t allLayersBytes = + Access::CachedGeneratedMeshStorageBytes(renderer); + EXPECT_GT(allLayersBytes, 0U); + EXPECT_EQ(Access::CachedGeneratedMeshStorage(renderer), 2U); + + std::swap(scene.layers[0], scene.layers[1]); + ASSERT_EQ(Access::PrepareFillMeshes(renderer, scene), S_OK); + EXPECT_EQ( + mwg::diagnostics::PerformanceDiagnostics::Snapshot().Counter( + mwg::diagnostics::PerformanceCounter::PolygonsTriangulated), + 2); + + const std::shared_ptr hiddenScene = + scene.layers[1].scene; + ASSERT_NE(hiddenScene, nullptr); + scene.skippedLayers.push_back( + {firstId, mwg::rendering::LayerSkipReason::Hidden, {}}); + scene.layers.erase(scene.layers.begin() + 1); + ASSERT_EQ(Access::PrepareFillMeshes(renderer, scene), S_OK); + EXPECT_EQ(Access::FillMeshCacheSize(renderer), 2U); + EXPECT_EQ( + mwg::diagnostics::PerformanceDiagnostics::Snapshot().Counter( + mwg::diagnostics::PerformanceCounter::PolygonsTriangulated), + 2); + + scene.skippedLayers.clear(); + ASSERT_EQ(Access::PrepareFillMeshes(renderer, scene), S_OK); + EXPECT_EQ(Access::FillMeshCacheSize(renderer), 1U); + EXPECT_EQ(Access::CachedGeneratedMeshStorage(renderer), 1U); + EXPECT_LT( + Access::CachedGeneratedMeshStorageBytes(renderer), + allLayersBytes); + EXPECT_EQ(scene.layers.front().layerId, secondId); + + (void)Edit(scene.layers.front()); + ASSERT_EQ(Access::PrepareFillMeshes(renderer, scene), S_OK); + EXPECT_EQ( + mwg::diagnostics::PerformanceDiagnostics::Snapshot().Counter( + mwg::diagnostics::PerformanceCounter::PolygonsTriangulated), + 3); + Access::InvalidateLayerSceneCache(renderer, secondId); + EXPECT_EQ(Access::FillMeshCacheSize(renderer), 0U); + ASSERT_EQ(Access::PrepareFillMeshes(renderer, scene), S_OK); + EXPECT_EQ( + mwg::diagnostics::PerformanceDiagnostics::Snapshot().Counter( + mwg::diagnostics::PerformanceCounter::PolygonsTriangulated), + 4); +} + +TEST(VectorLayerRenderer, OpenGlRejectsAnInvalidatedInFlightLayerWithoutClearingOthers) +{ + using Access = mwg::activex::testing::OpenGlVectorLayerRendererTestAccess; + mwg::rendering::MapRenderScene scene = MakeMapScene({ + mwg::rendering::VectorRenderScene{ + mwg::Extent{-3.0, -3.0, 3.0, 3.0}, + 1, + 0, + {{{{0.0, 3.0}, {2.0, -3.0}, {-3.0, 1.0}, + {3.0, 1.0}, {-2.0, -3.0}, {0.0, 3.0}}}}}, + MakeRectangleLayer({10.0, 0.0, 20.0, 10.0}), + MakeRectangleLayer({30.0, 0.0, 40.0, 10.0})}); + for (mwg::rendering::LayerRenderScene& layer : scene.layers) + { + Edit(layer).fillMeshes.clear(); + } + + mwg::activex::OpenGlVectorLayerRenderer renderer; + mwg::rendering::MapRenderScene retainedScene; + retainedScene.layers.push_back(scene.layers[1]); + retainedScene.layers.push_back(scene.layers[2]); + ASSERT_EQ(Access::PrepareFillMeshes(renderer, retainedScene), S_OK); + EXPECT_EQ(Access::FillMeshCacheSize(renderer), 2U); + + const mwg::LayerId invalidatedId = scene.layers.front().layerId; + bool callbackRan = false; + LogHandlerScope reentrantHandler( + [&renderer, &invalidatedId, &callbackRan]( + const mwg::LogLevel, + const std::string_view) + { + if (!callbackRan) + { + callbackRan = true; + Access::InvalidateLayerSceneCache(renderer, invalidatedId); + } + }); + + EXPECT_EQ(Access::PrepareFillMeshes(renderer, scene), S_FALSE); + EXPECT_TRUE(callbackRan); + EXPECT_EQ(Access::FillMeshCacheSize(renderer), 2U); + EXPECT_EQ(Access::CachedGeneratedMeshStorage(renderer), 2U); +} + TEST(VectorLayerRenderer, OpenGlSharesLazyMeshesWithTemporaryRenderers) { BitmapSurface surface(240, 201);