New Hardware Renderer: Add tool brush to mapview.qml

src/libtiledquick/libtiledquick.qbs

@@ -38,6 +38,8 @@ DynamicLibrary {
         "mapitem.h",
         "maploader.cpp",
         "maploader.h",
+        "regionoverlay.cpp",
+        "regionoverlay.h",
         "tiledquick_global.h",
         "tilelayeritem.cpp",
         "tilelayeritem.h",
@@ -71,6 +73,8 @@ DynamicLibrary {
         cpp.includePaths: exportingProduct.sourceDirectory
     }
 
+    Depends { name: "Qt.core" }
+
     install: !qbs.targetOS.contains("darwin")
     installDir: {
         if (qbs.targetOS.contains("windows"))

src/libtiledquick/mapgriditem.cpp

@@ -68,11 +68,12 @@ QSGNode *MapGridItem::updatePaintNode(QSGNode *node, QQuickItem::UpdatePaintNode
 
 void MapGridItem::setTileSize(const QPointF &tileSize)
 {
-    if (mTileSize != tileSize) {
-        mTileSize = tileSize;
-        emit tileSizeChanged();
-        update();
-    }
+    if (mTileSize == tileSize)
+        return;
+
+    mTileSize = tileSize;
+    emit tileSizeChanged();
+    update();
 }
 
 QPointF MapGridItem::tileSize() const
@@ -82,11 +83,12 @@ QPointF MapGridItem::tileSize() const
 
 void MapGridItem::setScale(const qreal &scale)
 {
-    if (mScale != scale) {
-        mScale = scale;
-        emit scaleChanged();
-        update();
-    }
+    if (mScale == scale)
+        return;
+
+    mScale = scale;
+    emit scaleChanged();
+    update();
 }
 
 qreal MapGridItem::scale() const
@@ -96,11 +98,12 @@ qreal MapGridItem::scale() const
 
 void MapGridItem::setColor(const QColor &color)
 {
-    if(mColor != color) {
-        mColor = color;
-        emit colorChanged();
-        update();
-    }
+    if (mColor == color)
+        return;
+
+    mColor = color;
+    emit colorChanged();
+    update();
 }
 
 QColor MapGridItem::color() const

src/libtiledquick/mapitem.cpp

@@ -30,6 +30,8 @@ using namespace TiledQuick;
 
 MapItem::MapItem(QQuickItem *parent)
     : QQuickItem(parent)
+    , mMap(nullptr)
+    , mEditableMap(nullptr)
 {
 }
 
@@ -40,8 +42,21 @@ void MapItem::setMap(Tiled::EditableMap *editableMap)
     if (mEditableMap == editableMap)
         return;
 
+    if (mEditableMap && mEditableMap->mapDocument()) {
+        Tiled::MapDocument *oldMapDocument = mEditableMap->mapDocument();
+        disconnect(oldMapDocument, &Tiled::MapDocument::regionChanged, this, &MapItem::repaintRegion);
+        disconnect(oldMapDocument, &Tiled::MapDocument::mapResized, this, &MapItem::refresh);
+    }
+
+    if (editableMap && editableMap->mapDocument()) {
+        Tiled::MapDocument *mapDocument = editableMap->mapDocument();
+        connect(mapDocument, &Tiled::MapDocument::regionChanged, this, &MapItem::repaintRegion);
+        connect(mapDocument, &Tiled::MapDocument::mapResized, this, &MapItem::refresh);
+    }
+
     mEditableMap = editableMap;
     mMap = editableMap ? editableMap->map() : nullptr;
+
     refresh();
     emit mapChanged();
 }
@@ -170,3 +185,14 @@ void MapItem::refresh()
     const QRect rect = mRenderer->mapBoundingRect();
     setImplicitSize(rect.width(), rect.height());
 }
+
+void MapItem::repaintRegion(const QRegion &, Tiled::TileLayer *tileLayer)
+{
+    for (TileLayerItem *tileLayerItem : std::as_const(mTileLayerItems)) {
+        if (tileLayer == tileLayerItem->layer()) {
+            // TODO: Update only the region edited
+            tileLayerItem->update();
+            continue;
+        }
+    }
+}

src/libtiledquick/mapitem.h

@@ -80,6 +80,8 @@ class TILEDQUICK_SHARED_EXPORT MapItem : public QQuickItem
 private:
     void refresh();
 
+    void repaintRegion(const QRegion &region, Tiled::TileLayer *tileLayer);
+
     Tiled::Map *mMap;
     Tiled::EditableMap *mEditableMap;
     QRectF mVisibleArea;

src/libtiledquick/regionoverlay.cpp

@@ -0,0 +1,95 @@
+/*
+ * regionoverlay.cpp
+ * Copyright 2026, UltraDagon
+ *
+ * This file is part of Tiled Quick.
+ *
+ * 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; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "regionoverlay.h"
+
+#include <QPainterPath>
+#include <QApplication>
+#include <QPalette>
+
+using namespace TiledQuick;
+
+RegionOverlay::RegionOverlay(QQuickItem *parent)
+    : QQuickItem(parent)
+    , mTileSize(0, 0)
+    , mRegion(QRegion())
+    , mColor(QApplication::palette().highlight().color())
+{
+}
+
+RegionOverlay::~RegionOverlay() = default;
+
+QList<QPolygonF> RegionOverlay::polygons() const
+{
+    QPainterPath path;
+
+    for (const QRect &r : mRegion.rects())
+        path.addRect(r);
+
+    QList<QPolygonF> polygons = path.simplified().toFillPolygons();
+
+    QTransform transform;
+    transform.scale(mTileSize.x(), mTileSize.y());
+
+    for (QPolygonF &polygon : polygons)
+        polygon = polygon * transform;
+
+    return polygons;
+}
+
+QColor RegionOverlay::strokeColor() const
+{
+    return mColor;
+}
+
+QColor RegionOverlay::fillColor() const
+{
+    QColor fillColor = mColor;
+    fillColor.setAlpha(64);
+    return fillColor;
+}
+
+QPointF RegionOverlay::tileSize() const
+{
+    return mTileSize;
+}
+
+void RegionOverlay::setTileSize(const QPointF &tileSize)
+{
+    if (mTileSize == tileSize)
+        return;
+
+    mTileSize = tileSize;
+    emit tileSizeChanged();
+}
+
+QRegion RegionOverlay::region() const
+{
+    return mRegion;
+}
+
+void RegionOverlay::setRegion(const QRegion &region)
+{
+    if (mRegion == region)
+        return;
+
+    mRegion = region;
+    emit regionChanged();
+}

src/libtiledquick/regionoverlay.h

@@ -0,0 +1,60 @@
+/*
+ * regionoverlay.h
+ * Copyright 2026, UltraDagon
+ *
+ * This file is part of Tiled Quick.
+ *
+ * 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; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QQuickItem>
+
+#include "tiledquick_global.h"
+
+namespace TiledQuick {
+
+class TILEDQUICK_SHARED_EXPORT RegionOverlay : public QQuickItem
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QPointF tileSize READ tileSize WRITE setTileSize NOTIFY tileSizeChanged)
+    Q_PROPERTY(QRegion region READ region WRITE setRegion NOTIFY regionChanged)
+
+public:
+    explicit RegionOverlay(QQuickItem *parent = nullptr);
+    ~RegionOverlay() override;
+
+    Q_INVOKABLE QList<QPolygonF> polygons() const;
+    Q_INVOKABLE QColor strokeColor() const;
+    Q_INVOKABLE QColor fillColor() const;
+
+    QPointF tileSize() const;
+    void setTileSize(const QPointF &tileSize);
+
+    QRegion region() const;
+    void setRegion(const QRegion &region);
+
+signals:
+    void tileSizeChanged();
+    void regionChanged();
+
+private:
+    QPointF mTileSize;
+    QRegion mRegion;
+    QColor mColor;
+};
+
+} // namespace TiledQuick

src/libtiledquick/tilelayeritem.cpp

@@ -136,8 +136,6 @@ void TileLayerItem::syncWithTileLayer()
     setSize(boundingRect.size());
 }
 
-
-
 QSGNode *TileLayerItem::updatePaintNode(QSGNode *node,
                                         QQuickItem::UpdatePaintNodeData *)
 {
@@ -201,6 +199,10 @@ QSGNode *TileLayerItem::updatePaintNode(QSGNode *node,
     return node;
 }
 
+Tiled::TileLayer *TileLayerItem::layer() {
+    return mLayer;
+}
+
 void TileLayerItem::updateVisibleTiles()
 {
     const MapItem *mapItem = static_cast<MapItem*>(parentItem());

src/libtiledquick/tilelayeritem.h

@@ -62,6 +62,8 @@ class TILEDQUICK_SHARED_EXPORT TileLayerItem : public QQuickItem
 
     QSGNode *updatePaintNode(QSGNode *node, UpdatePaintNodeData *) override;
 
+    Tiled::TileLayer *layer();
+
 public slots:
     void updateVisibleTiles();
 

src/tiled/abstracttilefilltool.cpp

@@ -229,6 +229,9 @@ void AbstractTileFillTool::updatePreview(const QRegion &fillRegion)
 
     preview->addTilesets(preview->usedTilesets());
 
+    emit brushMapChanged(preview.get());
+    emit brushRegionChanged(fillRegion);
+
     brushItem()->setMap(preview);
     mPreviewMap = preview;
 }
@@ -248,6 +251,8 @@ bool AbstractTileFillTool::applyPreview(const QString &text)
 
 void AbstractTileFillTool::clearOverlay()
 {
+    emit brushMapChanged(nullptr);
+
     brushItem()->clear();
     static_cast<WangBrushItem*>(brushItem())->setInvalidTiles(QRegion());
 

src/tiled/abstracttiletool.cpp

@@ -58,6 +58,11 @@ AbstractTileTool::~AbstractTileTool()
     delete mBrushItem;
 }
 
+QRegion AbstractTileTool::validRegion() const
+{
+    return mBrushItem->tileRegion();
+}
+
 void AbstractTileTool::activate(MapScene *scene)
 {
     scene->addItem(mBrushItem);
@@ -243,7 +248,7 @@ void AbstractTileTool::updateBrushVisibility()
         }
     }
 
-    mBrushItem->setVisible(showBrush);
+    mBrushItem->setVisible(showBrush || Preferences::instance()->useNewHardwareRenderer());
 }
 
 /**

src/tiled/abstracttiletool.h

@@ -52,6 +52,8 @@ class AbstractTileTool : public AbstractTool
 
     ~AbstractTileTool() override;
 
+    QRegion validRegion() const;
+
     void activate(MapScene *scene) override;
     void deactivate(MapScene *scene) override;
 
@@ -62,6 +64,10 @@ class AbstractTileTool : public AbstractTool
 
     void keyPressed(QKeyEvent *event) override;
 
+signals:
+    void brushMapChanged(Tiled::Map *map);
+    void brushRegionChanged(const QRegion &region);
+
 protected:
     void mapDocumentChanged(MapDocument *oldDocument,
                             MapDocument *newDocument) override;