tiledquickplugin: Only render visible tiles for all orientations (map…

…editor#2772) This change adds support for staggered and hexagonal maps to Tiled Quick, as well as making sure only visible tiles are rendered, reusing the rendering code from the MapRenderer. The small optimization that was used for orthogonal tile layers was dropped for the sake of simplicity. It is not expected to make much of an impact. Fixes mapeditor#2769 Co-authored-by: Thorbjørn Lindeijer <[email protected]>
vinnydiehl · Mar 18, 2020 · d3badef · d3badef
1 parent adc559a
commit d3badef
Show file tree

Hide file tree

Showing 11 changed files with 134 additions and 247 deletions.
diff --git a/src/libtiled/hexagonalrenderer.cpp b/src/libtiled/hexagonalrenderer.cpp
@@ -269,6 +269,17 @@ void HexagonalRenderer::drawGrid(QPainter *painter, const QRectF &exposed,
 void HexagonalRenderer::drawTileLayer(QPainter *painter,
                                       const TileLayer *layer,
                                       const QRectF &exposed) const
+{
+    CellRenderer renderer(painter, this, layer->effectiveTintColor(), CellRenderer::HexagonalCells);
+    auto tileRenderFunction = [&renderer](const Cell &cell, const QPointF &pos, const QSizeF &size) {
+        renderer.render(cell, pos, size, CellRenderer::BottomLeft);
+    };
+    drawTileLayer(layer, tileRenderFunction, exposed);
+}
+
+void HexagonalRenderer::drawTileLayer(const TileLayer *layer,
+                                      const RenderTileCallback &renderTile,
+                                      const QRectF &exposed) const
 {
     const RenderParams p(map());
 
@@ -307,8 +318,6 @@ void HexagonalRenderer::drawTileLayer(QPainter *painter,
     if (inLeftHalf)
         startTile.rx()--;
 
-    CellRenderer renderer(painter, this, layer->effectiveTintColor(), CellRenderer::HexagonalCells);
-
     const int endX = map()->infinite() ? layer->bounds().right() - layer->x() + 1 : layer->width();
     const int endY = map()->infinite() ? layer->bounds().bottom() - layer->y() + 1 : layer->height();
 
@@ -331,9 +340,9 @@ void HexagonalRenderer::drawTileLayer(QPainter *painter,
                 const Cell &cell = layer->cellAt(rowTile);
 
                 if (!cell.isEmpty()) {
-                    Tile *tile = cell.tile();
-                    QSize size = tile ? tile->size() : map()->tileSize();
-                    renderer.render(cell, rowPos, size, CellRenderer::BottomLeft);
+                    const Tile *tile = cell.tile();
+                    const QSize size = tile ? tile->size() : map()->tileSize();
+                    renderTile(cell, rowPos, size);
                 }
 
                 rowPos.rx() += p.tileWidth + p.sideLengthX;
@@ -376,9 +385,9 @@ void HexagonalRenderer::drawTileLayer(QPainter *painter,
                 const Cell &cell = layer->cellAt(rowTile);
 
                 if (!cell.isEmpty()) {
-                    Tile *tile = cell.tile();
-                    QSize size = tile ? tile->size() : map()->tileSize();
-                    renderer.render(cell, rowPos, size, CellRenderer::BottomLeft);
+                    const Tile *tile = cell.tile();
+                    const QSize size = tile ? tile->size() : map()->tileSize();
+                    renderTile(cell, rowPos, size);
                 }
 
                 rowPos.rx() += p.tileWidth + p.sideLengthX;

diff --git a/src/libtiled/hexagonalrenderer.h b/src/libtiled/hexagonalrenderer.h
@@ -79,6 +79,10 @@ class TILEDSHARED_EXPORT HexagonalRenderer : public OrthogonalRenderer
     void drawTileLayer(QPainter *painter, const TileLayer *layer,
                        const QRectF &exposed = QRectF()) const override;
 
+    void drawTileLayer(const TileLayer *layer,
+                       const RenderTileCallback &renderTile,
+                       const QRectF &exposed = QRectF()) const override;
+
     void drawTileSelection(QPainter *painter,
                            const QRegion &region,
                            const QColor &color,

diff --git a/src/libtiled/isometricrenderer.cpp b/src/libtiled/isometricrenderer.cpp
@@ -265,6 +265,17 @@ void IsometricRenderer::drawGrid(QPainter *painter, const QRectF &rect,
 void IsometricRenderer::drawTileLayer(QPainter *painter,
                                       const TileLayer *layer,
                                       const QRectF &exposed) const
+{
+    CellRenderer renderer(painter, this, layer->effectiveTintColor());
+    auto tileRenderFunction = [&renderer](const Cell &cell, const QPointF &pos, const QSizeF &size) {
+        renderer.render(cell, pos, size, CellRenderer::BottomLeft);
+    };
+    drawTileLayer(layer, tileRenderFunction, exposed);
+}
+
+void IsometricRenderer::drawTileLayer(const TileLayer *layer,
+                                      const RenderTileCallback &renderTile,
+                                      const QRectF &exposed) const
 {
     const int tileWidth = map()->tileWidth();
     const int tileHeight = map()->tileHeight();
@@ -318,8 +329,6 @@ void IsometricRenderer::drawTileLayer(QPainter *painter,
     // Determine whether the current row is shifted half a tile to the right
     bool shifted = inUpperHalf ^ inLeftHalf;
 
-    CellRenderer renderer(painter, this, layer->effectiveTintColor());
-
     for (int y = startPos.y() * 2; y - tileHeight * 2 < rect.bottom() * 2;
          y += tileHeight)
     {
@@ -328,10 +337,9 @@ void IsometricRenderer::drawTileLayer(QPainter *painter,
         for (int x = startPos.x(); x < rect.right(); x += tileWidth) {
             const Cell &cell = layer->cellAt(columnItr);
             if (!cell.isEmpty()) {
-                Tile *tile = cell.tile();
-                QSize size = (tile && !tile->image().isNull()) ? tile->size() : map()->tileSize();
-                renderer.render(cell, QPointF(x, (qreal)y / 2), size,
-                                CellRenderer::BottomLeft);
+                const Tile *tile = cell.tile();
+                const QSize size = (tile && !tile->image().isNull()) ? tile->size() : map()->tileSize();
+                renderTile(cell, QPointF(x, (qreal)y / 2), size);
             }
 
             // Advance to the next column

diff --git a/src/libtiled/isometricrenderer.h b/src/libtiled/isometricrenderer.h
@@ -57,6 +57,10 @@ class TILEDSHARED_EXPORT IsometricRenderer final : public MapRenderer
     void drawTileLayer(QPainter *painter, const TileLayer *layer,
                        const QRectF &exposed = QRectF()) const override;
 
+    void drawTileLayer(const TileLayer *layer,
+                       const RenderTileCallback &renderTile,
+                       const QRectF &exposed = QRectF()) const override;
+
     void drawTileSelection(QPainter *painter,
                            const QRegion &region,
                            const QColor &color,

diff --git a/src/libtiled/maprenderer.h b/src/libtiled/maprenderer.h
@@ -30,6 +30,8 @@
 
 #include "tiled_global.h"
 
+#include <functional>
+
 #include <QPainter>
 
 namespace Tiled {
@@ -130,6 +132,8 @@ class TILEDSHARED_EXPORT MapRenderer
     virtual void drawGrid(QPainter *painter, const QRectF &rect,
                           QColor gridColor = Qt::black) const = 0;
 
+    typedef std::function<void(const Cell &, const QPointF &, const QSizeF &)> RenderTileCallback;
+
     /**
      * Draws the given \a layer using the given \a painter.
      *
@@ -139,6 +143,16 @@ class TILEDSHARED_EXPORT MapRenderer
     virtual void drawTileLayer(QPainter *painter, const TileLayer *layer,
                                const QRectF &exposed = QRectF()) const = 0;
 
+    /**
+     * Draws the given \a layer using the given \a renderTile callback.
+     *
+     * Optionally, you can pass in the \a exposed rect (of pixels), so that
+     * only tiles that can be visible in this area will be drawn.
+     */
+    virtual void drawTileLayer(const TileLayer *layer,
+                               const RenderTileCallback &renderTile,
+                               const QRectF &exposed = QRectF()) const = 0;
+
     /**
      * Draws the tile selection given by \a region in the specified \a color.
      *

diff --git a/src/libtiled/orthogonalrenderer.cpp b/src/libtiled/orthogonalrenderer.cpp
@@ -265,6 +265,17 @@ void OrthogonalRenderer::drawTileLayer(QPainter *painter,
                                        const TileLayer *layer,
                                        const QRectF &exposed) const
 {
+    CellRenderer renderer(painter, this, layer->effectiveTintColor());
+    auto tileRenderFunction = [&renderer](const Cell &cell, const QPointF &pos, const QSizeF &size) {
+        renderer.render(cell, pos, size, CellRenderer::BottomLeft);
+    };
+    drawTileLayer(layer, tileRenderFunction, exposed);
+}
+
+void OrthogonalRenderer::drawTileLayer(const TileLayer *layer,
+                                       const RenderTileCallback &renderTile,
+                                       const QRectF &exposed) const
+{
 
     const int tileWidth = map()->tileWidth();
     const int tileHeight = map()->tileHeight();
@@ -302,11 +313,6 @@ void OrthogonalRenderer::drawTileLayer(QPainter *painter,
     if (startX > endX || startY > endY)
         return;
 
-    const QTransform savedTransform = painter->transform();
-    painter->translate(layerPos);
-
-    CellRenderer renderer(painter, this, layer->effectiveTintColor());
-
     Map::RenderOrder renderOrder = map()->renderOrder();
 
     int incX = 1, incY = 1;
@@ -338,18 +344,11 @@ void OrthogonalRenderer::drawTileLayer(QPainter *painter,
             if (cell.isEmpty())
                 continue;
 
-            Tile *tile = cell.tile();
-            QSize size = (tile && !tile->image().isNull()) ? tile->size() : map()->tileSize();
-            renderer.render(cell,
-                            QPointF(x * tileWidth, (y + 1) * tileHeight),
-                            size,
-                            CellRenderer::BottomLeft);
+            const Tile *tile = cell.tile();
+            const QSize size = (tile && !tile->image().isNull()) ? tile->size() : map()->tileSize();
+            renderTile(cell, layerPos + QPointF(x * tileWidth, (y + 1) * tileHeight), size);
         }
     }
-
-    renderer.flush();
-
-    painter->setTransform(savedTransform);
 }
 
 void OrthogonalRenderer::drawTileSelection(QPainter *painter,

diff --git a/src/libtiled/orthogonalrenderer.h b/src/libtiled/orthogonalrenderer.h
@@ -55,6 +55,10 @@ class TILEDSHARED_EXPORT OrthogonalRenderer : public MapRenderer
     void drawTileLayer(QPainter *painter, const TileLayer *layer,
                        const QRectF &exposed = QRectF()) const override;
 
+    void drawTileLayer(const TileLayer *layer,
+                       const RenderTileCallback &renderTile,
+                       const QRectF &exposed = QRectF()) const override;
+
     void drawTileSelection(QPainter *painter,
                            const QRegion &region,
                            const QColor &color,

diff --git a/src/tiledquickplugin/mapitem.cpp b/src/tiledquickplugin/mapitem.cpp
@@ -22,9 +22,11 @@
 
 #include "tilelayeritem.h"
 
+#include "hexagonalrenderer.h"
 #include "isometricrenderer.h"
 #include "map.h"
 #include "orthogonalrenderer.h"
+#include "staggeredrenderer.h"
 #include "tilelayer.h"
 
 #include <cmath>
@@ -55,34 +57,6 @@ void MapItem::setVisibleArea(const QRectF &visibleArea)
     emit visibleAreaChanged();
 }
 
-/**
- * Determines the rectangle of visible tiles of the given tile \a layer, based
- * on the visible area of this MapItem instance.
- *
- * Only works for orthogonal maps.
- */
-QRect MapItem::visibleTileArea(const Tiled::TileLayer *layer) const
-{
-    const int tileWidth = mMap->tileWidth();
-    const int tileHeight = mMap->tileHeight();
-
-    QMargins drawMargins = layer->drawMargins();
-    drawMargins.setTop(drawMargins.top() - tileHeight);
-    drawMargins.setRight(drawMargins.right() - tileWidth);
-
-    QRectF rect = visibleArea().adjusted(-drawMargins.right(),
-                                         -drawMargins.bottom(),
-                                         drawMargins.left(),
-                                         drawMargins.top());
-
-    int startX = qMax((int) rect.x() / tileWidth, 0);
-    int startY = qMax((int) rect.y() / tileHeight, 0);
-    int endX = qMin((int) std::ceil(rect.right()) / tileWidth, layer->width() - 1);
-    int endY = qMin((int) std::ceil(rect.bottom()) / tileHeight, layer->height() - 1);
-
-    return QRect(QPoint(startX, startY), QPoint(endX, endY));
-}
-
 QRectF MapItem::boundingRect() const
 {
     if (!mRenderer)
@@ -182,11 +156,17 @@ void MapItem::refresh()
         return;
 
     switch (mMap->orientation()) {
+    default:
+        mRenderer = std::make_unique<Tiled::OrthogonalRenderer>(mMap);
+        break;
     case Tiled::Map::Isometric:
         mRenderer = std::make_unique<Tiled::IsometricRenderer>(mMap);
         break;
-    default:
-        mRenderer = std::make_unique<Tiled::OrthogonalRenderer>(mMap);
+    case Tiled::Map::Staggered:
+        mRenderer = std::make_unique<Tiled::StaggeredRenderer>(mMap);
+        break;
+    case Tiled::Map::Hexagonal:
+        mRenderer = std::make_unique<Tiled::HexagonalRenderer>(mMap);
         break;
     }
 

diff --git a/src/tiledquickplugin/mapitem.h b/src/tiledquickplugin/mapitem.h
@@ -27,8 +27,6 @@
 namespace Tiled {
 class Map;
 class MapRenderer;
-class Tileset;
-class TileLayer;
 } // namespace Tiled
 
 namespace TiledQuick {
@@ -55,7 +53,6 @@ class MapItem : public QQuickItem
 
     const QRectF &visibleArea() const;
     void setVisibleArea(const QRectF &visibleArea);
-    QRect visibleTileArea(const Tiled::TileLayer *layer) const;
 
     QRectF boundingRect() const;