improve: drawpool

src/client/client.cpp

@@ -81,10 +81,18 @@ void Client::preLoad() {
 
 void Client::draw(const DrawPoolType type)
 {
+    if (type == DrawPoolType::FOREGROUND) {
+        g_ui.render(DrawPoolType::FOREGROUND);
+        if (!g_game.isOnline())
+            m_mapWidget = nullptr;
+        return;
+    }
+
     if (!g_game.isOnline()) {
         m_mapWidget = nullptr;
         return;
     }
+
     if (m_mapWidget && m_mapWidget->isDestroyed())
         m_mapWidget = nullptr;
     if (type == DrawPoolType::MAP && !m_mapWidget)
@@ -93,22 +101,26 @@ void Client::draw(const DrawPoolType type)
     if (!m_mapWidget)
         return;
 
-    if (type == DrawPoolType::FOREGROUND_MAP)
+    if (type == DrawPoolType::FOREGROUND_MAP) {
         g_textDispatcher.poll();
+        m_mapWidget->draw(DrawPoolType::CREATURE_INFORMATION);
+    }
 
     m_mapWidget->draw(type);
 }
 
 bool Client::canDraw(const DrawPoolType type) const
 {
     switch (type) {
+        case DrawPoolType::MAP:
+            return g_game.isOnline();
+
         case DrawPoolType::FOREGROUND:
-            return true;
+            return g_drawPool.get(type)->canRepaint();
 
-        case DrawPoolType::MAP:
         case DrawPoolType::CREATURE_INFORMATION:
         case DrawPoolType::FOREGROUND_MAP:
-            return g_game.isOnline();
+            return g_game.isOnline() && g_drawPool.get(type)->canRepaint();
 
         case DrawPoolType::LIGHT:
             return g_game.isOnline() && m_mapWidget && m_mapWidget->isDrawingLights();

src/client/lightview.cpp

@@ -48,7 +48,8 @@ void LightView::resize(const Size& size, const uint16_t tileSize) {
     m_lightData.tiles.resize(size.area());
     m_lightData.lights.clear();
 
-    m_pixels.resize(size.area() * 4);
+    for (auto& pixels : m_pixels)
+        pixels.resize(size.area() * 4);
 
     if (m_texture)
         m_texture->setupSize(m_mapSize);
@@ -93,15 +94,16 @@ void LightView::draw(const Rect& dest, const Rect& src)
     m_pool->getHashController().put(src.hash());
     m_pool->getHashController().put(m_globalLightColor.hash());
     if (m_pool->getHashController().wasModified()) {
-        std::scoped_lock l(m_pool->getMutex());
         updatePixels();
+        std::scoped_lock l(m_pool->getMutex());
+        m_pixels[0].swap(m_pixels[1]);
         pixelUpdated = true;
     }
     m_pool->getHashController().reset();
 
     g_drawPool.addAction([=, this] {
         if (pixelUpdated) {
-            m_texture->updatePixels(m_pixels.data());
+            m_texture->updatePixels(m_pixels[1].data());
             pixelUpdated = false;
         }
 
@@ -110,12 +112,9 @@ void LightView::draw(const Rect& dest, const Rect& src)
         g_painter->setCompositionMode(CompositionMode::MULTIPLY);
         g_painter->resetTransformMatrix();
         g_painter->resetColor();
-        g_painter->setTexture(m_texture->getId(), m_texture->getTransformMatrixId());
+        g_painter->setTexture(m_texture);
         g_painter->drawCoords(m_coords);
     });
-
-    m_lightData.lights.clear();
-    m_lightData.tiles.assign(m_mapSize.area(), {});
 }
 
 void LightView::updateCoords(const Rect& dest, const Rect& src) {
@@ -142,7 +141,7 @@ void LightView::updatePixels()
     const auto tileCenterOffset = m_tileSize / 2;
     const auto invTileSize = 1.0f / m_tileSize;
 
-    auto* pixelData = m_pixels.data();
+    auto* pixelData = m_pixels[0].data();
 
     for (int y = 0; y < mapHeight; ++y) {
         for (int x = 0; x < mapWidth; ++x) {

src/client/lightview.h

@@ -49,6 +49,10 @@ class LightView final : public LuaObject
     bool isDark() const { return m_isDark; }
     bool isEnabled() const { return m_pool->isEnabled(); }
     void setEnabled(const bool v) { m_pool->setEnable(v); }
+    void clear() {
+        m_lightData.lights.clear();
+        m_lightData.tiles.assign(m_mapSize.area(), {});
+    }
 
 private:
     struct TileLight : Light
@@ -80,5 +84,5 @@ class LightView final : public LuaObject
     CoordsBuffer m_coords;
     TexturePtr m_texture;
     LightData m_lightData;
-    std::vector<uint8_t> m_pixels;
+    std::array<std::vector<uint8_t>, 2> m_pixels;
 };

src/client/uimap.cpp

@@ -55,6 +55,7 @@ void UIMap::draw(const DrawPoolType drawPane) {
         }, m_mapView->m_posInfo.rect, m_mapView->m_posInfo.srcRect, Color::black);
     } else if (drawPane == DrawPoolType::LIGHT) {
         g_drawPool.preDraw(drawPane, [this] {
+            m_mapView->m_lightView->clear();
             m_mapView->drawLights();
             m_mapView->m_lightView->draw(m_mapView->m_posInfo.rect, m_mapView->m_posInfo.srcRect);
         }, true);

src/framework/core/graphicalapplication.cpp

@@ -178,9 +178,6 @@ void GraphicalApplication::run()
 #endif
     // THREAD - POOL & MAP
     const auto& mapThread = g_asyncDispatcher.submit_task([this] {
-        const auto uiPool = g_drawPool.get(DrawPoolType::FOREGROUND);
-        const auto fgMapPool = g_drawPool.get(DrawPoolType::FOREGROUND_MAP);
-
         BS::multi_future<void> tasks;
 
         g_luaThreadId = g_eventThreadId = stdext::getThreadId();
@@ -192,40 +189,25 @@ void GraphicalApplication::run()
                 continue;
             }
 
-            if (!m_drawEvents->canDraw(DrawPoolType::MAP)) {
-                if (uiPool->canRepaint())
-                    g_ui.render(DrawPoolType::FOREGROUND);
-                m_mapProcessFrameCounter.update();
-                continue;
-            }
+            if (m_drawEvents->canDraw(DrawPoolType::MAP)) {
+                m_drawEvents->preLoad();
 
-            m_drawEvents->preLoad();
+                for (const auto type : { DrawPoolType::LIGHT , DrawPoolType::FOREGROUND, DrawPoolType::FOREGROUND_MAP }) {
+                    if (m_drawEvents->canDraw(type)) {
+                        tasks.emplace_back(g_asyncDispatcher.submit_task([this, type] {
+                            m_drawEvents->draw(type);
+                        }));
+                    }
+                }
 
-            tasks.clear();
-
-            if (m_drawEvents->canDraw(DrawPoolType::LIGHT)) {
-                tasks.emplace_back(g_asyncDispatcher.submit_task([this] {
-                    m_drawEvents->draw(DrawPoolType::LIGHT);
-                }));
-            }
+                m_drawEvents->draw(DrawPoolType::MAP);
 
-            if (uiPool->canRepaint()) {
-                tasks.emplace_back(g_asyncDispatcher.submit_task([this] {
-                    g_ui.render(DrawPoolType::FOREGROUND);
-                }));
+                tasks.wait();
+                tasks.clear();
+            } else if (m_drawEvents->canDraw(DrawPoolType::FOREGROUND)) {
+                g_ui.render(DrawPoolType::FOREGROUND);
             }
 
-            if (fgMapPool->canRepaint()) {
-                tasks.emplace_back(g_asyncDispatcher.submit_task([this] {
-                    m_drawEvents->draw(DrawPoolType::CREATURE_INFORMATION);
-                    m_drawEvents->draw(DrawPoolType::FOREGROUND_MAP);
-                }));
-            }
-
-            m_drawEvents->draw(DrawPoolType::MAP);
-
-            tasks.wait();
-
             m_mapProcessFrameCounter.update();
         }
     });

src/framework/graphics/drawpool.cpp

@@ -30,18 +30,15 @@ DrawPool* DrawPool::create(const DrawPoolType type)
         if (type == DrawPoolType::MAP) {
             pool->m_framebuffer->m_useAlphaWriting = false;
             pool->m_framebuffer->disableBlend();
-        }
-        else if (type == DrawPoolType::FOREGROUND) {
+        } else if (type == DrawPoolType::FOREGROUND) {
             pool->setFPS(10);
 
             // creates a temporary framebuffer with smoothing.
             pool->m_temporaryFramebuffers.emplace_back(std::make_shared<FrameBuffer>());
         }
-    }
-    else if (type == DrawPoolType::LIGHT) {
+    } else if (type == DrawPoolType::LIGHT) {
         pool->m_hashCtrl = true;
-    }
-    else {
+    } else {
         pool->m_alwaysGroupDrawings = true; // CREATURE_INFORMATION & TEXT
         pool->setFPS(60);
     }
@@ -61,8 +58,7 @@ void DrawPool::add(const Color& color, const TexturePtr& texture, DrawMethod&& m
     if (m_type == DrawPoolType::FOREGROUND) {
         order = FIRST;
         agroup = false;
-    }
-    else if (m_type == DrawPoolType::MAP && order == FIRST && !conductor.agroup)
+    } else if (m_type == DrawPoolType::MAP && order == FIRST && !conductor.agroup)
         order = THIRD;
 
     if (agroup) {
@@ -76,8 +72,7 @@ void DrawPool::add(const Color& color, const TexturePtr& texture, DrawMethod&& m
             coords->append(coordsBuffer.get());
         else
             addCoords(coords, method);
-    }
-    else {
+    } else {
         bool addNewObj = true;
 
         auto& list = m_objects[order];
@@ -99,8 +94,7 @@ void DrawPool::add(const Color& color, const TexturePtr& texture, DrawMethod&& m
 
             if (coordsBuffer) {
                 draw.coords->append(coordsBuffer.get());
-            }
-            else
+            } else
                 addCoords(draw.coords.get(), method);
         }
     }
@@ -112,17 +106,13 @@ void DrawPool::addCoords(CoordsBuffer* buffer, const DrawMethod& method)
 {
     if (method.type == DrawMethodType::BOUNDING_RECT) {
         buffer->addBoudingRect(method.dest, method.intValue);
-    }
-    else if (method.type == DrawMethodType::RECT) {
+    } else if (method.type == DrawMethodType::RECT) {
         buffer->addRect(method.dest, method.src);
-    }
-    else if (method.type == DrawMethodType::TRIANGLE) {
+    } else if (method.type == DrawMethodType::TRIANGLE) {
         buffer->addTriangle(method.a, method.b, method.c);
-    }
-    else if (method.type == DrawMethodType::UPSIDEDOWN_RECT) {
+    } else if (method.type == DrawMethodType::UPSIDEDOWN_RECT) {
         buffer->addUpsideDownRect(method.dest, method.src);
-    }
-    else if (method.type == DrawMethodType::REPEATED_RECT) {
+    } else if (method.type == DrawMethodType::REPEATED_RECT) {
         buffer->addRepeatedRects(method.dest, method.src);
     }
 }
@@ -167,11 +157,9 @@ bool DrawPool::updateHash(const DrawMethod& method, const TexturePtr& texture, c
             if (!method.a.isNull()) stdext::hash_union(hash, method.a.hash());
             if (!method.b.isNull()) stdext::hash_union(hash, method.b.hash());
             if (!method.c.isNull()) stdext::hash_union(hash, method.c.hash());
-        }
-        else if (method.type == DrawMethodType::BOUNDING_RECT) {
+        } else if (method.type == DrawMethodType::BOUNDING_RECT) {
             if (method.intValue) stdext::hash_combine(hash, method.intValue);
-        }
-        else {
+        } else {
             if (method.dest.isValid()) stdext::hash_union(hash, method.dest.hash());
             if (method.src.isValid()) stdext::hash_union(hash, method.src.hash());
         }
@@ -193,8 +181,7 @@ DrawPool::PoolState DrawPool::getState(const TexturePtr& texture, const Color& c
     if (texture) {
         if (texture->isEmpty() || !texture->isCached()) {
             copy.texture = texture;
-        }
-        else {
+        } else {
             copy.textureId = texture->getId();
             copy.textureMatrixId = texture->getTransformMatrixId();
         }
@@ -238,8 +225,7 @@ void DrawPool::setShaderProgram(const PainterShaderProgramPtr& shaderProgram, co
 
         getCurrentState().shaderProgram = shaderProgram.get();
         getCurrentState().action = action;
-    }
-    else {
+    } else {
         getCurrentState().shaderProgram = nullptr;
         getCurrentState().action = nullptr;
     }
@@ -267,7 +253,7 @@ void DrawPool::resetState()
 
 bool DrawPool::canRepaint()
 {
-    if (m_repaint)
+    if (isDrawing())
         return false;
 
     uint16_t refreshDelay = m_refreshDelay;
@@ -346,8 +332,7 @@ void DrawPool::PoolState::execute() const {
     if (texture) {
         texture->create();
         g_painter->setTexture(texture->getId(), texture->getTransformMatrixId());
-    }
-    else
+    } else
         g_painter->setTexture(textureId, textureMatrixId);
 }
 
@@ -392,7 +377,7 @@ void DrawPool::bindFrameBuffer(const Size& size, const Color& color)
         const auto& frame = getTemporaryFrameBuffer(frameIndex);
         frame->resize(size);
         frame->bind();
-        });
+    });
 }
 void DrawPool::releaseFrameBuffer(const Rect& dest)
 {
@@ -403,7 +388,7 @@ void DrawPool::releaseFrameBuffer(const Rect& dest)
         frame->release();
         drawState.execute();
         frame->draw(dest);
-        });
+    });
 
     if (hasFrameBuffer() && !dest.isNull()) m_hashCtrl.put(dest.hash());
     --m_bindedFramebuffers;