fix #405

src/client/creature.cpp

@@ -35,6 +35,7 @@
 #include <framework/graphics/drawpoolmanager.h>
 #include <framework/graphics/graphics.h>
 #include <framework/graphics/texturemanager.h>
+#include <framework/graphics/framebuffermanager.h>
 
 double Creature::speedA = 0;
 double Creature::speedB = 0;
@@ -196,13 +197,29 @@ void Creature::drawOutfit(const Rect& destRect, bool resize, const Color color)
     else if ((frameSize = m_exactSize) == 0)
         return;
 
-    const float scaleFactor = destRect.width() / static_cast<float>(frameSize);
-    const Point dest = destRect.bottomRight() - (Point(SPRITE_SIZE) - getDisplacement()) * scaleFactor;
+    const auto& oldClipRect = g_drawPool.getClipRect();
+    g_drawPool.resetClipRect();
 
-    const float oldScaleFactor = g_drawPool.getScaleFactor();
-    g_drawPool.setScaleFactor(scaleFactor);
-    internalDrawOutfit(dest, TextureType::SMOOTH, color);
-    g_drawPool.setScaleFactor(oldScaleFactor);
+    const auto& drawState = g_drawPool.getState();
+    g_drawPool.addAction([destRect, frameSize, drawState] {
+        drawState.execute();
+
+        const auto& frame = g_framebuffers.getTemporaryFrameBuffer();
+        frame->resize(frameSize);
+        frame->bind(destRect, Rect(0, 0, frame->getSize()));
+    });
+
+    internalDrawOutfit(Point(frameSize - SPRITE_SIZE, frameSize - SPRITE_SIZE) + getDisplacement(), TextureType::NONE, color);
+
+    g_drawPool.addAction([drawState] {
+        drawState.execute();
+
+        const auto& frame = g_framebuffers.getTemporaryFrameBuffer();
+        frame->release();
+        frame->draw();
+    });
+
+    g_drawPool.setClipRect(oldClipRect);
 }
 
 void Creature::drawInformation(const MapPosInfo& mapRect, const Point& dest, bool useGray, int drawFlags)

src/client/uicreature.cpp

@@ -30,8 +30,7 @@ void UICreature::drawSelf(DrawPoolType drawPane)
     UIWidget::drawSelf(drawPane);
 
     if (m_creature) {
-        const Rect drawRect = getPaddingRect();
-        m_creature->drawOutfit(drawRect, !m_fixedCreatureSize, m_imageColor);
+        m_creature->drawOutfit(getPaddingRect(), !m_fixedCreatureSize, m_imageColor);
     }
 }
 

src/framework/graphics/drawpool.cpp

@@ -32,8 +32,10 @@ DrawPool* DrawPool::create(const DrawPoolType type)
         pool = new DrawPoolFramed;
 
         const auto& frameBuffer = pool->toPoolFramed()->m_framebuffer;
+        frameBuffer->m_isScane = true;
+
         if (type == DrawPoolType::MAP) {
-            frameBuffer->setUseAlphaWriting(false);
+            frameBuffer->m_useAlphaWriting = false;
             frameBuffer->disableBlend();
         } else if (type == DrawPoolType::FOREGROUND) {
             pool->m_refreshDelay = 100; // 10 FPS (1000 / 10)
@@ -274,19 +276,13 @@ void DrawPool::setShaderProgram(const PainterShaderProgramPtr& shaderProgram, bo
 
 void DrawPool::resetState()
 {
-    resetOpacity();
-    resetClipRect();
-    resetShaderProgram();
-    resetBlendEquation();
-    resetCompositionMode();
-    resetTransformMatrix();
-
     for (auto& objs : m_objects) {
         for (auto& order : objs)
             order.clear();
     }
 
     m_objectsByhash.clear();
+    m_state = {};
     m_currentFloor = 0;
     m_status.second = 0;
     m_shaderRefreshDelay = 0;
@@ -370,3 +366,16 @@ void DrawPool::optimize(int size) {
 
     m_alwaysGroupDrawings = size > 115; // Max optimization
 }
+
+void DrawPool::PoolState::execute() const {
+    g_painter->setColor(color);
+    g_painter->setOpacity(opacity);
+    g_painter->setCompositionMode(compositionMode);
+    g_painter->setBlendEquation(blendEquation);
+    g_painter->setClipRect(clipRect);
+    g_painter->setShaderProgram(shaderProgram);
+    g_painter->setTransformMatrix(transformMatrix);
+    if (action) action();
+    if (texture)
+        g_painter->setTexture(texture->create());
+}

src/framework/graphics/drawpool.h

@@ -72,8 +72,6 @@ class DrawPool
     void setScaleFactor(float scale) { m_scaleFactor = scale; }
     inline float getScaleFactor() const { return m_scaleFactor; }
 
-    void resetState();
-
     std::mutex& getMutex() { return m_mutex; }
 
     struct PoolState
@@ -85,13 +83,16 @@ class DrawPool
         Rect clipRect;
         PainterShaderProgram* shaderProgram{ nullptr };
         std::function<void()> action{ nullptr };
-        Color color;
+        Color color{ Color::white };
         TexturePtr texture;
         size_t hash{ 0 };
 
         bool operator==(const PoolState& s2) const { return hash == s2.hash; }
+        void execute() const;
     };
 
+    const PoolState& getState() const { return m_state; }
+
 protected:
 
     enum class DrawMethodType
@@ -160,6 +161,8 @@ class DrawPool
              DrawMode drawMode = DrawMode::TRIANGLES, const DrawBufferPtr& drawBuffer = nullptr,
              const CoordsBufferPtr& coordsBuffer = nullptr);
 
+    void resetState();
+
     size_t updateHash(PoolState& state, const DrawPool::DrawMethod& method);
 
     float getOpacity() const { return m_state.opacity; }

src/framework/graphics/drawpoolmanager.cpp

@@ -110,20 +110,7 @@ void DrawPoolManager::drawObject(const DrawPool::DrawObject& obj)
             DrawPool::addCoords(&buffer, method, obj.drawMode);
     }
 
-    { // Set DrawState
-        const auto& state = obj.state;
-        g_painter->setColor(state.color);
-        g_painter->setOpacity(state.opacity);
-        g_painter->setCompositionMode(state.compositionMode);
-        g_painter->setBlendEquation(state.blendEquation);
-        g_painter->setClipRect(state.clipRect);
-        g_painter->setShaderProgram(state.shaderProgram);
-        g_painter->setTransformMatrix(state.transformMatrix);
-        if (state.action) state.action();
-        if (state.texture)
-            g_painter->setTexture(state.texture->create());
-    }
-
+    obj.state.execute();
     g_painter->drawCoords(buffer, obj.drawMode);
 }
 

src/framework/graphics/drawpoolmanager.h

@@ -63,6 +63,7 @@ class DrawPoolManager
 
     float getOpacity() const { return getCurrentPool()->getOpacity(); }
     Rect getClipRect() const { return getCurrentPool()->getClipRect(); }
+    const DrawPool::PoolState& getState() const { return getCurrentPool()->getState(); }
 
     void resetState() const { getCurrentPool()->resetState(); }
     void resetOpacity() const { getCurrentPool()->resetOpacity(); }

src/framework/graphics/framebuffer.cpp

@@ -78,19 +78,31 @@ void FrameBuffer::bind()
 {
     internalBind();
 
-    g_painter->resetState();
+    if (m_isScane) {
+        g_painter->resetState();
+    } else {
+        m_oldSize = g_painter->getResolution();
+        m_oldTextureMatrix = g_painter->getProjectionMatrix();
+    }
+
     g_painter->setResolution(getSize(), m_textureMatrix);
     g_painter->setAlphaWriting(m_useAlphaWriting);
 
     if (m_colorClear != Color::alpha) {
         g_painter->setTexture(nullptr);
         g_painter->setColor(m_colorClear);
         g_painter->drawCoords(m_screenCoordsBuffer, DrawMode::TRIANGLE_STRIP);
+    } else if (!m_isScane) {
+        g_painter->clear(Color::alpha);
     }
 }
 
 void FrameBuffer::draw()
 {
+    if (!m_isScane) {
+        g_painter->setResolution(m_oldSize, m_oldTextureMatrix);
+    }
+
     if (m_disableBlend) glDisable(GL_BLEND);
     g_painter->setCompositionMode(m_compositeMode);
     g_painter->setTexture(m_texture.get());

src/framework/graphics/framebuffer.h

@@ -34,10 +34,10 @@ class FrameBuffer
 
     void release() const { internalRelease(); };
     void bind();
+    void bind(const Rect& dest, const Rect& src) { prepare(dest, src); bind(); }
     void draw();
 
     void setSmooth(bool enabled) { m_smooth = enabled; m_texture = nullptr; }
-    void setUseAlphaWriting(bool use) { m_useAlphaWriting = use; }
 
     bool resize(const Size& size);
     bool isValid() const { return m_texture != nullptr; }
@@ -55,6 +55,7 @@ class FrameBuffer
 
     friend class FrameBufferManager;
     friend class DrawPoolManager;
+    friend class DrawPool;
 
 private:
     static uint32_t boundFbo;
@@ -63,7 +64,9 @@ class FrameBuffer
     void internalRelease() const;
     void prepare(const Rect& dest, const Rect& src, const Color& colorClear = Color::alpha);
 
-    Matrix3 m_textureMatrix;
+    Size m_oldSize;
+
+    Matrix3 m_textureMatrix, m_oldTextureMatrix;
     TexturePtr m_texture;
 
     uint32_t m_fbo{ 0 };
@@ -74,6 +77,7 @@ class FrameBuffer
     bool m_smooth{ true };
     bool m_useAlphaWriting{ true };
     bool m_disableBlend{ false };
+    bool m_isScane{ false };
 
     Rect m_dest;
     Rect m_src;