Painting performance improvements - Tiled buffer

app/src/mainwindow2.cpp

@@ -1442,7 +1442,7 @@ void MainWindow2::makeConnections(Editor* editor, ColorInspector* colorInspector
 
 void MainWindow2::makeConnections(Editor* editor, ScribbleArea* scribbleArea)
 {
-    connect(editor->tools(), &ToolManager::toolChanged, scribbleArea, &ScribbleArea::setCurrentTool);
+    connect(editor->tools(), &ToolManager::toolChanged, scribbleArea, &ScribbleArea::updateToolCursor);
     connect(editor->tools(), &ToolManager::toolChanged, mToolBox, &ToolBoxWidget::onToolSetActive);
     connect(editor->tools(), &ToolManager::toolPropertyChanged, scribbleArea, &ScribbleArea::updateToolCursor);
 

core_lib/core_lib.pro

@@ -34,6 +34,8 @@ HEADERS +=  \
     src/corelib-pch.h \
     src/graphics/bitmap/bitmapbucket.h \
     src/graphics/bitmap/bitmapimage.h \
+    src/graphics/bitmap/tile.h \
+    src/graphics/bitmap/tiledbuffer.h \
     src/graphics/vector/bezierarea.h \
     src/graphics/vector/beziercurve.h \
     src/graphics/vector/colorref.h \
@@ -119,6 +121,8 @@ HEADERS +=  \
 
 SOURCES +=  src/graphics/bitmap/bitmapimage.cpp \
     src/graphics/bitmap/bitmapbucket.cpp \
+    src/graphics/bitmap/tile.cpp \
+    src/graphics/bitmap/tiledbuffer.cpp \
     src/graphics/vector/bezierarea.cpp \
     src/graphics/vector/beziercurve.cpp \
     src/graphics/vector/colorref.cpp \

core_lib/src/canvaspainter.cpp

@@ -23,6 +23,8 @@ GNU General Public License for more details.
 #include "layerbitmap.h"
 #include "layervector.h"
 #include "bitmapimage.h"
+#include "layercamera.h"
+#include "tiledbuffer.h"
 #include "vectorimage.h"
 
 #include "painterutils.h"
@@ -151,7 +153,7 @@ void CanvasPainter::renderPostLayers(QPainter& painter, const QRect& blitRect)
     }
 }
 
-void CanvasPainter::setPaintSettings(const Object* object, int currentLayer, int frame, QRect rect, BitmapImage* buffer)
+void CanvasPainter::setPaintSettings(const Object* object, int currentLayer, int frame, QRect rect, TiledBuffer* tiledBuffer)
 {
     Q_UNUSED(rect)
     Q_ASSERT(object);
@@ -160,7 +162,7 @@ void CanvasPainter::setPaintSettings(const Object* object, int currentLayer, int
     CANVASPAINTER_LOG("Set CurrentLayerIndex = %d", currentLayer);
     mCurrentLayerIndex = currentLayer;
     mFrameNumber = frame;
-    mBuffer = buffer;
+    mTiledBuffer = tiledBuffer;
 }
 
 void CanvasPainter::paint(const QRect& blitRect)
@@ -283,24 +285,47 @@ void CanvasPainter::paintCurrentBitmapFrame(QPainter& painter, const QRect& blit
     if (paintedImage == nullptr) { return; }
     paintedImage->loadFile(); // Critical! force the BitmapImage to load the image
 
-    const bool isDrawing = mBuffer && !mBuffer->bounds().isEmpty();
+    const bool isDrawing = mTiledBuffer && !mTiledBuffer->bounds().isEmpty();
 
     QPainter currentBitmapPainter;
     initializePainter(currentBitmapPainter, mCurrentLayerPixmap, blitRect);
 
     painter.setOpacity(paintedImage->getOpacity() - (1.0-painter.opacity()));
     painter.setWorldMatrixEnabled(false);
 
-    currentBitmapPainter.drawImage(paintedImage->topLeft(), *paintedImage->image());
-
+    bool shouldPaintTransformedSelection = mRenderTransform;
     if (isCurrentLayer) {
         if (isDrawing) {
-            // paint the current stroke data which hasn't been applied to a bitmapImage yet
-            currentBitmapPainter.setCompositionMode(mOptions.cmBufferBlendMode);
-            currentBitmapPainter.drawImage(mBuffer->topLeft(), *mBuffer->image());
-        } else if (mRenderTransform) {
-            paintTransformedSelection(currentBitmapPainter, paintedImage, mSelection);
+
+            // Certain tools require being painted continously, for example the Polyline tool.
+            // The tiled buffer does not update the area outside of which it paints,
+            // so in the case in order to see the previously laid down polyline stroke
+            // the area around it must be drawn again before
+            // applying the new tiled output on top
+            if (mOptions.bIgnoreCanvasBuffer) {
+                currentBitmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
+                currentBitmapPainter.drawImage(paintedImage->topLeft(), *paintedImage->image());
+            }
+
+            const auto tiles = mTiledBuffer->tiles();
+            for (const Tile* tile : tiles) {
+                currentBitmapPainter.drawPixmap(tile->pos(), tile->pixmap());
+            }
         }
+    } else {
+        // We do not wish to draw selection transformations on anything but the current layer
+        shouldPaintTransformedSelection = false;
+    }
+
+    // When we're drawing using a tool, the surface will be painted by the tiled buffer
+    // and thus we don't want to paint the current image again
+    // When we're on another layer though, the tiled buffer is not used
+    if (!isCurrentLayer || !isDrawing) {
+        currentBitmapPainter.drawImage(paintedImage->topLeft(), *paintedImage->image());
+    }
+
+    if (shouldPaintTransformedSelection) {
+        paintTransformedSelection(currentBitmapPainter, paintedImage, mSelection);
     }
 
     painter.drawPixmap(blitRect, mCurrentLayerPixmap, blitRect);
@@ -318,15 +343,19 @@ void CanvasPainter::paintCurrentVectorFrame(QPainter& painter, const QRect& blit
     QPainter currentVectorPainter;
     initializePainter(currentVectorPainter, mCurrentLayerPixmap, blitRect);
 
-    const bool isDrawing = mBuffer && !mBuffer->bounds().isEmpty();
+    const bool isDrawing = mTiledBuffer->isValid();
 
     // Paint existing vector image to the painter
     vectorImage->paintImage(currentVectorPainter, mOptions.bOutlines, mOptions.bThinLines, mOptions.bAntiAlias);
 
     if (isCurrentLayer) {
         if (isDrawing) {
             currentVectorPainter.setCompositionMode(mOptions.cmBufferBlendMode);
-            currentVectorPainter.drawImage(mBuffer->topLeft(), *mBuffer->image());
+
+            const auto tiles = mTiledBuffer->tiles();
+            for (const Tile* tile : tiles) {
+                currentVectorPainter.drawPixmap(tile->pos(), tile->pixmap());
+            }
         } else if (mRenderTransform) {
             vectorImage->setSelectionTransformation(mSelectionTransform);
         }
@@ -336,7 +365,7 @@ void CanvasPainter::paintCurrentVectorFrame(QPainter& painter, const QRect& blit
     painter.setWorldMatrixEnabled(false);
     painter.setTransform(QTransform());
 
-    // Remember to adjust opacity based on addition opacity value from image
+    // Remember to adjust opacity based on additional opacity value from the keyframe
     painter.setOpacity(vectorImage->getOpacity() - (1.0-painter.opacity()));
     painter.drawPixmap(blitRect, mCurrentLayerPixmap, blitRect);
 }

core_lib/src/canvaspainter.h

@@ -30,6 +30,8 @@ GNU General Public License for more details.
 #include "onionskinpainteroptions.h"
 #include "onionskinsubpainter.h"
 
+
+class TiledBuffer;
 class Object;
 class BitmapImage;
 class ViewManager;
@@ -39,6 +41,10 @@ struct CanvasPainterOptions
     bool  bAntiAlias = false;
     bool  bThinLines = false;
     bool  bOutlines = false;
+
+    /// When using a tool that can't rely on canvas buffer,
+    /// for example Polyline because we're continously clearing the surface
+    bool  bIgnoreCanvasBuffer = false;
     LayerVisibility eLayerVisibility = LayerVisibility::RELATED;
     float fLayerVisibilityThreshold = 0.f;
     float scaling = 1.0f;
@@ -61,7 +67,7 @@ class CanvasPainter
     void setTransformedSelection(QRect selection, QTransform transform);
     void ignoreTransformedSelection();
 
-    void setPaintSettings(const Object* object, int currentLayer, int frame, QRect rect, BitmapImage* buffer);
+    void setPaintSettings(const Object* object, int currentLayer, int frame, QRect rect, TiledBuffer* tilledBuffer);
     void paint(const QRect& blitRect);
     void paintCached(const QRect& blitRect);
     void resetLayerCache();
@@ -102,7 +108,7 @@ class CanvasPainter
 
     int mCurrentLayerIndex = 0;
     int mFrameNumber = 0;
-    BitmapImage* mBuffer = nullptr;
+    TiledBuffer* mTiledBuffer = nullptr;
 
     QImage mScaledBitmap;
 

core_lib/src/graphics/bitmap/bitmapimage.cpp

@@ -24,6 +24,7 @@ GNU General Public License for more details.
 #include "util.h"
 
 #include "blitrect.h"
+#include "tiledbuffer.h"
 
 BitmapImage::BitmapImage()
 {
@@ -98,7 +99,7 @@ BitmapImage* BitmapImage::clone() const
     b->setFileName(""); // don't link to the file of the source bitmap image
 
     const bool validKeyFrame = !fileName().isEmpty();
-    if (validKeyFrame && !isLoaded()) 
+    if (validKeyFrame && !isLoaded())
     {
         // This bitmapImage is temporarily unloaded.
         // since it's not in the memory, we need to copy the linked png file to prevent data loss.
@@ -204,6 +205,28 @@ void BitmapImage::paste(BitmapImage* bitmapImage, QPainter::CompositionMode cm)
     modification();
 }
 
+void BitmapImage::paste(const TiledBuffer* tiledBuffer, QPainter::CompositionMode cm)
+{
+    if(tiledBuffer->bounds().width() <= 0 || tiledBuffer->bounds().height() <= 0)
+    {
+        return;
+    }
+    extend(tiledBuffer->bounds());
+
+    QPainter painter(image());
+
+    painter.setCompositionMode(cm);
+    auto const tiles = tiledBuffer->tiles();
+    for (const Tile* item : tiles) {
+        const QPixmap& tilePixmap = item->pixmap();
+        const QPoint& tilePos = item->pos();
+        painter.drawPixmap(tilePos-mBounds.topLeft(), tilePixmap);
+    }
+    painter.end();
+
+    modification();
+}
+
 void BitmapImage::moveTopLeft(QPoint point)
 {
     mBounds.moveTopLeft(point);
@@ -624,7 +647,9 @@ void BitmapImage::drawRect(QRectF rectangle, QPen pen, QBrush brush, QPainter::C
         painter.setRenderHint(QPainter::Antialiasing, antialiasing);
         painter.setPen(pen);
         painter.setBrush(brush);
-        painter.drawRect(rectangle.translated(-mBounds.topLeft()));
+
+        // Adjust the brush rectangle to be bigger than the bounds itself, otherwise there will be artifacts shown in some cases
+        painter.drawRect(rectangle.translated(-mBounds.topLeft()).adjusted(-1, -1, 1, 1));
         painter.end();
     }
     modification();

core_lib/src/graphics/bitmap/bitmapimage.h

@@ -22,6 +22,8 @@ GNU General Public License for more details.
 #include <QtMath>
 #include <QHash>
 
+class TiledBuffer;
+
 
 class BitmapImage : public KeyFrame
 {
@@ -50,6 +52,7 @@ class BitmapImage : public KeyFrame
     BitmapImage copy();
     BitmapImage copy(QRect rectangle);
     void paste(BitmapImage*, QPainter::CompositionMode cm = QPainter::CompositionMode_SourceOver);
+    void paste(const TiledBuffer* tiledBuffer, QPainter::CompositionMode cm = QPainter::CompositionMode_SourceOver);
 
     void moveTopLeft(QPoint point);
     void moveTopLeft(QPointF point) { moveTopLeft(point.toPoint()); }

core_lib/src/graphics/bitmap/tile.cpp

@@ -0,0 +1,42 @@
+/*
+
+Pencil2D - Traditional Animation Software
+Copyright (C) 2012-2020 Matthew Chiawen Chang
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+*/
+
+#include "tile.h"
+
+Tile::Tile(QSize size):
+    mTilePixmap(size)
+{
+    clear(); //Default tiles are transparent
+}
+
+Tile::Tile(QPixmap& pixmap)
+{
+    mTilePixmap = pixmap;
+}
+
+Tile::~Tile()
+{
+}
+
+QRect Tile::boundingRect() const
+{
+    return mTilePixmap.rect();
+}
+
+void Tile::clear()
+{
+    mTilePixmap.fill(Qt::transparent);
+}

core_lib/src/graphics/bitmap/tile.h

@@ -0,0 +1,46 @@
+/*
+
+Pencil2D - Traditional Animation Software
+Copyright (C) 2012-2020 Matthew Chiawen Chang
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+*/
+
+#ifndef TILE_H
+#define TILE_H
+
+#include <QPoint>
+#include <QPixmap>
+
+class Tile
+{
+public:
+
+    explicit Tile (QSize size);
+    explicit Tile (QPixmap& pixmap);
+    ~Tile();
+
+    const QPixmap& pixmap() const { return mTilePixmap; }
+    QPixmap& pixmap() { return mTilePixmap; }
+
+    QRect boundingRect() const;
+
+    void clear();
+
+    void setPos(const QPoint& pos) { m_pos = pos; }
+    QPoint pos() const { return m_pos; }
+
+private:
+    QPixmap    mTilePixmap;
+    QPoint m_pos;
+};
+
+#endif // TILE_H