Add support for Tileset Grid Atlas

deathbeam · deathbeam · commit f0ded07f4993 · 2025-02-06T16:48:08.000+01:00
- Add new "atlas" property to tileset that determines if tileset is atlas tileset or not
- Atlas property is set on tileset creation through type
- When atlas tileset is loaded, if it doesnt have any image rects image rects for every tile on tileset will be generated
- Atlas tileset always saves all image rects
- Atlas tilesets use tile ids based on position on tileset so they are consistent on tile deletion/recreation

Atlas is editable in **Rearrange Tiles** mode:
- Tiles can be merged by holding down left click (this creates multi tile tile)
- Tiles can be split by right clicking on multi tile edges
- Tiles can be removed from atlas by right clicking single tiles (so needs to be split first then removed) - current limitation, ideally right click hold would delete multiple, but this is probably not super common use case and the visual seection doesnt work for right click, QT limitation maybe?
- Tiles can be added back to atlas by left clicking empty tiles

Signed-off-by: Tomas Slusny &lt;slusnucky@gmail.com&gt;
diff --git a/src/libtiled/maptovariantconverter.cpp b/src/libtiled/maptovariantconverter.cpp
@@ -185,6 +185,7 @@ QVariant MapToVariantConverter::toVariant(const Tileset &tileset,
     tilesetVariant[QStringLiteral("name")] = tileset.name();
     if (!tileset.className().isEmpty())
         tilesetVariant[QStringLiteral("class")] = tileset.className();
+    tilesetVariant[QStringLiteral("atlas")] = tileset.isAtlas();
     tilesetVariant[QStringLiteral("tilewidth")] = tileset.tileWidth();
     tilesetVariant[QStringLiteral("tileheight")] = tileset.tileHeight();
     tilesetVariant[QStringLiteral("spacing")] = tileset.tileSpacing();
@@ -302,14 +303,13 @@ QVariant MapToVariantConverter::toVariant(const Tileset &tileset,
                 tileVariant[QStringLiteral("imagewidth")] = imageSize.width();
                 tileVariant[QStringLiteral("imageheight")] = imageSize.height();
             }
-
-            const QRect &imageRect = tile->imageRect();
-            if (!imageRect.isNull() && imageRect != tile->image().rect() && tileset.isCollection()) {
-                tileVariant[QStringLiteral("x")] = imageRect.x();
-                tileVariant[QStringLiteral("y")] = imageRect.y();
-                tileVariant[QStringLiteral("width")] = imageRect.width();
-                tileVariant[QStringLiteral("height")] = imageRect.height();
-            }
+        }
+        const QRect &imageRect = tile->imageRect();
+        if (!imageRect.isNull() && imageRect != tile->image().rect() && (tileset.isCollection() || tileset.isAtlas())) {
+            tileVariant[QStringLiteral("x")] = imageRect.x();
+            tileVariant[QStringLiteral("y")] = imageRect.y();
+            tileVariant[QStringLiteral("width")] = imageRect.width();
+            tileVariant[QStringLiteral("height")] = imageRect.height();
         }
         if (tile->objectGroup())
             tileVariant[QStringLiteral("objectgroup")] = toVariant(*tile->objectGroup());
diff --git a/src/libtiled/mapwriter.cpp b/src/libtiled/mapwriter.cpp
@@ -413,15 +413,16 @@ void MapWriterPrivate::writeTileset(QXmlStreamWriter &w, const Tileset &tileset,
                QSize(tileset.imageWidth(), tileset.imageHeight()));
 
     const bool isCollection = tileset.isCollection();
-    const bool includeAllTiles = isCollection || tileset.anyTileOutOfOrder();
+    const bool isAtlas = tileset.isAtlas();
+    const bool includeAllTiles = isCollection || isAtlas || tileset.anyTileOutOfOrder();
 
     for (const Tile *tile : tileset.tiles()) {
         if (includeAllTiles || includeTile(tile)) {
             w.writeStartElement(QStringLiteral("tile"));
             w.writeAttribute(QStringLiteral("id"), QString::number(tile->id()));
 
             const QRect &imageRect = tile->imageRect();
-            if (!imageRect.isNull() && imageRect != tile->image().rect() && isCollection) {
+            if (!imageRect.isNull() && imageRect != tile->image().rect() && (isCollection || isAtlas)) {
                 w.writeAttribute(QStringLiteral("x"),
                                  QString::number(imageRect.x()));
                 w.writeAttribute(QStringLiteral("y"),
diff --git a/src/libtiled/tileset.cpp b/src/libtiled/tileset.cpp
@@ -38,14 +38,15 @@
 namespace Tiled {
 
 Tileset::Tileset(QString name, int tileWidth, int tileHeight,
-                 int tileSpacing, int margin)
+                 int tileSpacing, int margin, bool isAtlas)
     : Object(TilesetType)
     , mName(std::move(name))
     , mTileWidth(tileWidth)
     , mTileHeight(tileHeight)
     , mTileSpacing(tileSpacing)
     , mMargin(margin)
     , mGridSize(tileWidth, tileHeight)
+    , mAtlas(isAtlas)
 {
     Q_ASSERT(tileSpacing >= 0);
     Q_ASSERT(margin >= 0);
@@ -253,40 +254,58 @@ bool Tileset::initializeTilesetTiles()
     if (mImageReference.transparentColor.isValid())
         mImage.setMask(mImage.createMaskFromColor(mImageReference.transparentColor));
 
-    QVector<QRect> tileRects;
-
-    for (int y = mMargin; y <= mImage.height() - mTileHeight; y += mTileHeight + mTileSpacing)
-        for (int x = mMargin; x <= mImage.width() - mTileWidth; x += mTileWidth + mTileSpacing)
-            tileRects.append(QRect(x, y, mTileWidth, mTileHeight));
-
-    for (int tileNum = 0; tileNum < tileRects.size(); ++tileNum) {
-        auto it = mTilesById.find(tileNum);
-        if (it != mTilesById.end()) {
-            it.value()->setImage(QPixmap());    // make sure it uses the tileset's image
-            it.value()->setImageRect(tileRects.at(tileNum));
-        } else {
-            auto tile = new Tile(tileNum, this);
-            tile->setImageRect(tileRects.at(tileNum));
-            mTilesById.insert(tileNum, tile);
-            mTiles.insert(tileNum, tile);
+    bool needsRectGeneration = true;
+    if (isAtlas()) {
+        for (Tile *tile : std::as_const(mTiles)) {
+            if (!tile->imageRect().isNull()) {
+                needsRectGeneration = false;
+                break;
+            }
         }
     }
 
-    QPixmap blank;
+    if (needsRectGeneration) {
+        QVector<QRect> tileRects;
+
+        for (int y = mMargin; y <= mImage.height() - mTileHeight; y += mTileHeight + mTileSpacing)
+            for (int x = mMargin; x <= mImage.width() - mTileWidth; x += mTileWidth + mTileSpacing)
+                tileRects.append(QRect(x, y, mTileWidth, mTileHeight));
+
+        for (int tileNum = 0; tileNum < tileRects.size(); ++tileNum) {
+            QRect rect = tileRects.at(tileNum);
+            const int tileId = isAtlas() ? generateTileId(rect.x(), rect.y(), true) : tileNum;
+            auto it = mTilesById.find(tileId);
+            if (it != mTilesById.end()) {
+                it.value()->setImage(QPixmap());    // make sure it uses the tileset's image
+                it.value()->setImageRect(tileRects.at(tileNum));
+            } else {
+                auto tile = new Tile(tileId, this);
+                tile->setImageRect(rect);
+                mTilesById.insert(tileId, tile);
+                mTiles.insert(tileNum, tile);
+            }
+        }
 
-    // Blank out any remaining tiles to avoid confusion (todo: could be more clear)
-    for (Tile *tile : std::as_const(mTiles)) {
-        if (tile->id() >= tileRects.size()) {
-            if (blank.isNull()) {
-                blank = QPixmap(mTileWidth, mTileHeight);
-                blank.fill();
+        QPixmap blank;
+
+        // Blank out any remaining tiles to avoid confusion (todo: could be more clear)
+        if (!isAtlas()) {
+            for (Tile *tile : std::as_const(mTiles)) {
+                if (tile->id() >= tileRects.size()) {
+                    if (blank.isNull()) {
+                        blank = QPixmap(mTileWidth, mTileHeight);
+                        blank.fill();
+                    }
+                    tile->setImage(blank);
+                    tile->setImageRect(QRect(0, 0, mTileWidth, mTileHeight));
+                }
             }
-            tile->setImage(blank);
-            tile->setImageRect(QRect(0, 0, mTileWidth, mTileHeight));
         }
     }
 
-    mNextTileId = std::max<int>(mNextTileId, tileRects.size());
+    for (Tile *tile : std::as_const(mTiles)) {
+        mNextTileId = std::max(mNextTileId, tile->id() + 1);
+    }
 
     mImageReference.size = mImage.size();
     mColumnCount = columnCountForWidth(mImageReference.size.width());
@@ -453,6 +472,9 @@ void Tileset::addTiles(const QList<Tile *> &tiles)
         Q_ASSERT(tile->tileset() == this && !mTilesById.contains(tile->id()));
         mTilesById.insert(tile->id(), tile);
         mTiles.append(tile);
+        if (isAtlas()) {
+            setNextTileId(std::max(nextTileId(), tile->id() + 1));
+        }
     }
 
     updateTileSize();
@@ -469,6 +491,9 @@ void Tileset::removeTiles(const QList<Tile *> &tiles)
         Q_ASSERT(tile->tileset() == this && mTilesById.contains(tile->id()));
         mTilesById.remove(tile->id());
         mTiles.removeOne(tile);
+        if (isAtlas()) {
+            setNextTileId(std::max(nextTileId(), tile->id() + 1));
+        }
     }
 
     updateTileSize();
@@ -554,6 +579,9 @@ void Tileset::setTileImageRect(Tile *tile, const QRect &imageRect)
 
 void Tileset::maybeUpdateTileSize(QSize previousTileSize, QSize newTileSize)
 {
+    if (isAtlas())
+        return;
+
     if (previousTileSize == newTileSize)
         return;
 
@@ -681,6 +709,9 @@ SharedTileset Tileset::clone() const
  */
 void Tileset::updateTileSize()
 {
+    if (isAtlas())
+        return;
+
     int maxWidth = 0;
     int maxHeight = 0;
     for (Tile *tile : std::as_const(mTiles)) {
@@ -694,6 +725,18 @@ void Tileset::updateTileSize()
     mTileHeight = maxHeight;
 }
 
+int Tileset::generateTileId(int x, int y, bool absolute) const {
+    if (absolute) {
+        // Normalize x and y to tile coordinates
+        x = (x - mMargin) / (mTileWidth + mTileSpacing);
+        y = (y - mMargin) / (mTileHeight + mTileSpacing);
+    }
+
+    // Use 12+12 bit spatial hash (4096x4096 coordinates limit)
+    x &= 0xFFF;
+    y &= 0xFFF;
+    return (x << 12) | y; // 24 bits total
+}
 
 QString Tileset::orientationToString(Tileset::Orientation orientation)
 {
diff --git a/src/libtiled/tileset.h b/src/libtiled/tileset.h
@@ -120,7 +120,7 @@ class TILEDSHARED_EXPORT Tileset : public Object, public QEnableSharedFromThis<T
      * pointer is initialized, which enables the sharedPointer() function.
      */
     Tileset(QString name, int tileWidth, int tileHeight,
-            int tileSpacing = 0, int margin = 0);
+            int tileSpacing = 0, int margin = 0, bool isAtlas = false);
 
 public:
     QString exportFileName;
@@ -138,6 +138,9 @@ class TILEDSHARED_EXPORT Tileset : public Object, public QEnableSharedFromThis<T
     void setFormat(const QString &format);
     QString format() const;
 
+    bool isAtlas() const { return mAtlas; }
+    void setAtlas(bool atlas) { mAtlas = atlas; }
+
     int tileWidth() const;
     int tileHeight() const;
 
@@ -235,6 +238,11 @@ class TILEDSHARED_EXPORT Tileset : public Object, public QEnableSharedFromThis<T
     int nextTileId() const;
     int takeNextTileId();
 
+    /**
+     * Generates a tile ID from grid column and row coordinates or absolute coordinates
+     */
+    int generateTileId(int x, int y, bool absolute = false) const;
+
     void setTileImage(Tile *tile,
                       const QPixmap &image,
                       const QUrl &source = QUrl());
@@ -311,6 +319,7 @@ class TILEDSHARED_EXPORT Tileset : public Object, public QEnableSharedFromThis<T
     TileRenderSize mTileRenderSize = TileSize;
     FillMode mFillMode = Stretch;
     QSize mGridSize;
+    bool mAtlas;
     int mColumnCount = 0;
     int mExpectedColumnCount = 0;
     int mExpectedRowCount = 0;
diff --git a/src/libtiled/varianttomapconverter.cpp b/src/libtiled/varianttomapconverter.cpp
@@ -220,6 +220,7 @@ SharedTileset VariantToMapConverter::toTileset(const QVariant &variant)
     }
 
     const QString name = variantMap[QStringLiteral("name")].toString();
+    const bool atlas = variantMap[QStringLiteral("atlas")].toBool();
     const QString className = variantMap[QStringLiteral("class")].toString();
     const int tileWidth = variantMap[QStringLiteral("tilewidth")].toInt();
     const int tileHeight = variantMap[QStringLiteral("tileheight")].toInt();
@@ -244,7 +245,7 @@ SharedTileset VariantToMapConverter::toTileset(const QVariant &variant)
 
     SharedTileset tileset(Tileset::create(name,
                                           tileWidth, tileHeight,
-                                          spacing, margin));
+                                          spacing, margin, atlas));
 
     tileset->setClassName(className);
     tileset->setObjectAlignment(alignmentFromString(objectAlignment));
diff --git a/src/tiled/newtilesetdialog.cpp b/src/tiled/newtilesetdialog.cpp
@@ -47,6 +47,7 @@ static SessionOption<int> tilesetMargin { "tileset.margin" };
 
 enum TilesetType {
     TilesetImage,
+    TilesetAtlas,
     ImageCollection
 };
 
@@ -57,6 +58,8 @@ static TilesetType tilesetType(Ui::NewTilesetDialog *ui)
     case 0:
         return TilesetImage;
     case 1:
+        return TilesetAtlas;
+    case 2:
         return ImageCollection;
     }
 }
@@ -93,7 +96,7 @@ NewTilesetDialog::NewTilesetDialog(QWidget *parent) :
     connect(mUi->buttonBox, &QDialogButtonBox::accepted, this, &NewTilesetDialog::tryAccept);
     connect(mUi->buttonBox, &QDialogButtonBox::rejected, this, &NewTilesetDialog::reject);
 
-    mUi->imageGroupBox->setVisible(session::tilesetType == 0);
+    mUi->imageGroupBox->setVisible(session::tilesetType < 2);
     updateOkButton();
 }
 
@@ -187,10 +190,11 @@ bool NewTilesetDialog::editTilesetParameters(TilesetParameters &parameters)
 void NewTilesetDialog::tryAccept()
 {
     const QString name = mUi->name->text();
+    const TilesetType type = tilesetType(mUi);
 
     SharedTileset tileset;
 
-    if (tilesetType(mUi) == TilesetImage) {
+    if (type == TilesetImage || type == TilesetAtlas) {
         const QString image = mUi->image->text();
         const bool useTransparentColor = mUi->useTransparentColor->isChecked();
         const QColor transparentColor = mUi->colorButton->color();
@@ -201,7 +205,8 @@ void NewTilesetDialog::tryAccept()
 
         tileset = Tileset::create(name,
                                   tileWidth, tileHeight,
-                                  spacing, margin);
+                                  spacing, margin,
+                                  type == TilesetAtlas);
 
         if (useTransparentColor)
             tileset->setTransparentColor(transparentColor);
@@ -281,7 +286,7 @@ void NewTilesetDialog::nameEdited(const QString &name)
 
 void NewTilesetDialog::tilesetTypeChanged(int index)
 {
-    mUi->imageGroupBox->setVisible(index == 0);
+    mUi->imageGroupBox->setVisible(index < 2);
     updateOkButton();
 }
 
diff --git a/src/tiled/newtilesetdialog.ui b/src/tiled/newtilesetdialog.ui
@@ -69,6 +69,11 @@
           <string>Based on Tileset Image</string>
          </property>
         </item>
+        <item>
+         <property name="text">
+          <string>Tileset Grid Atlas</string>
+         </property>
+        </item>
         <item>
          <property name="text">
           <string>Collection of Images</string>
diff --git a/src/tiled/propertieswidget.cpp b/src/tiled/propertieswidget.cpp
@@ -1319,6 +1319,13 @@ class TilesetProperties : public ObjectProperties
                         push(new RenameTileset(tilesetDocument(), value));
                     });
 
+        mAtlasProperty = new BoolProperty(
+                    tr("Atlas"),
+                    [this] {
+                        return tileset()->isAtlas();
+                    });
+        mAtlasProperty->setEnabled(false);
+
         mObjectAlignmentProperty = new EnumProperty<Alignment>(
                     tr("Object Alignment"),
                     [this] {
@@ -1445,6 +1452,7 @@ class TilesetProperties : public ObjectProperties
 
         mTilesetProperties = new GroupProperty(tr("Tileset"));
         mTilesetProperties->addProperty(mNameProperty);
+        mTilesetProperties->addProperty(mAtlasProperty);
         mTilesetProperties->addProperty(mClassProperty);
         mTilesetProperties->addSeparator();
         mTilesetProperties->addProperty(mObjectAlignmentProperty);
@@ -1526,6 +1534,7 @@ class TilesetProperties : public ObjectProperties
 
     GroupProperty *mTilesetProperties;
     Property *mNameProperty;
+    Property *mAtlasProperty;
     Property *mObjectAlignmentProperty;
     PointProperty *mTileOffsetProperty;
     Property *mTileRenderSizeProperty;
diff --git a/src/tiled/tilesetmodel.cpp b/src/tiled/tilesetmodel.cpp
diff --git a/src/tiled/tilesetmodel.h b/src/tiled/tilesetmodel.h
diff --git a/src/tiled/tilesetview.cpp b/src/tiled/tilesetview.cpp
diff --git a/src/tiled/tilesetview.h b/src/tiled/tilesetview.h
