Allow pixel based drawing/selection on atlas tileset

Signed-off-by: Tomas Slusny <[email protected]>

Author: deathbeam

src/libtiled/tileset.cpp

@@ -272,16 +272,14 @@ bool Tileset::initializeTilesetTiles()
                 tileRects.append(QRect(x, y, mTileWidth, mTileHeight));
 
         for (int tileNum = 0; tileNum < tileRects.size(); ++tileNum) {
-            QRect rect = tileRects.at(tileNum);
-            const int tileId = tileNum;
-            auto it = mTilesById.find(tileId);
+            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(tileId, this);
-                tile->setImageRect(rect);
-                mTilesById.insert(tileId, tile);
+                auto tile = new Tile(tileNum, this);
+                tile->setImageRect(tileRects.at(tileNum));
+                mTilesById.insert(tileNum, tile);
                 mTiles.insert(tileNum, tile);
             }
         }
@@ -718,42 +716,6 @@ void Tileset::updateTileSize()
     mTileHeight = maxHeight;
 }
 
-QPoint Tileset::pixelToGrid(const QPoint &pixelPos) const
-{
-    return QPoint(
-        (pixelPos.x() - mMargin) / (mTileWidth + mTileSpacing),
-        (pixelPos.y() - mMargin) / (mTileHeight + mTileSpacing)
-    );
-}
-
-QPoint Tileset::gridToPixel(const QPoint &gridPos) const
-{
-    return QPoint(
-        mMargin + gridPos.x() * (mTileWidth + mTileSpacing),
-        mMargin + gridPos.y() * (mTileHeight + mTileSpacing)
-    );
-}
-
-QRect Tileset::pixelToGrid(const QRect &pixelRect) const
-{
-    const QPoint topLeft = pixelToGrid(pixelRect.topLeft());
-    const QSize size(
-        pixelRect.width() / mTileWidth,
-        pixelRect.height() / mTileHeight
-    );
-    return QRect(topLeft, size);
-}
-
-QRect Tileset::gridToPixel(const QRect &gridRect) const
-{
-    const QPoint topLeft = gridToPixel(gridRect.topLeft());
-    return QRect(
-        topLeft.x(), topLeft.y(),
-        gridRect.width() * mTileWidth,
-        gridRect.height() * mTileHeight
-    );
-}
-
 QString Tileset::orientationToString(Tileset::Orientation orientation)
 {
     switch (orientation) {

src/libtiled/tileset.h

@@ -238,12 +238,6 @@ class TILEDSHARED_EXPORT Tileset : public Object, public QEnableSharedFromThis<T
     int nextTileId() const;
     int takeNextTileId();
 
-    // Convert between pixel and grid coordinates
-    QPoint pixelToGrid(const QPoint &pixelPos) const;
-    QPoint gridToPixel(const QPoint &gridPos) const;
-    QRect pixelToGrid(const QRect &pixelRect) const;
-    QRect gridToPixel(const QRect &gridRect) const;
-
     void setTileImage(Tile *tile,
                       const QPixmap &image,
                       const QUrl &source = QUrl());

src/tiled/newtilesetdialog.ui

@@ -71,7 +71,7 @@
         </item>
         <item>
          <property name="text">
-          <string>Tileset Grid Atlas</string>
+          <string>Tileset Atlas</string>
          </property>
         </item>
         <item>

src/tiled/tilesetmodel.cpp

@@ -32,11 +32,6 @@
 
 using namespace Tiled;
 
-inline uint qHash(const QPoint &p, uint seed = 0)
-{
-    return qHash(p.x(), seed) ^ qHash(p.y(), seed);
-}
-
 TilesetModel::TilesetModel(TilesetDocument *tilesetDocument, QObject *parent)
     : QAbstractListModel(parent)
     , mTilesetDocument(tilesetDocument)
@@ -49,37 +44,13 @@ TilesetModel::TilesetModel(TilesetDocument *tilesetDocument, QObject *parent)
             this, &TilesetModel::tileChanged);
 }
 
-QPoint TilesetModel::viewToAtlasCoords(int viewCol, int viewRow) const
-{
-    const int currentCols = columnCount();
-    const int atlasCols = tileset()->columnCount();
-    const int linearIndex = viewCol + viewRow * currentCols;
-    return QPoint(linearIndex % atlasCols,
-                 linearIndex / atlasCols);
-}
-
-QPoint TilesetModel::atlasToViewCoords(int atlasCol, int atlasRow) const
-{
-    const int currentCols = columnCount();
-    const int atlasCols = tileset()->columnCount();
-    const int linearIndex = atlasRow * atlasCols + atlasCol;
-    return QPoint(linearIndex % currentCols,
-                 linearIndex / currentCols);
-}
-
 int TilesetModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid())
         return 0;
 
-    if (tileset()->isAtlas()) {
-        const int currentCols = columnCount();
-        if (currentCols <= 0)
-            return 1;
-
-        const int totalTiles = tileset()->rowCount() * tileset()->columnCount();
-        return (totalTiles + currentCols - 1) / currentCols;
-    }
+    if (tileset()->isAtlas() && mColumnCountOverride <= 0)
+        return 1;
 
     const int tileCount = mTileIds.size();
     const int columns = columnCount();
@@ -100,13 +71,23 @@ int TilesetModel::columnCount(const QModelIndex &parent) const
         return 0;
     if (mColumnCountOverride > 0)
         return mColumnCountOverride;
+    if (tileset()->isAtlas())
+        return 1;
     if (tileset()->columnCount())
         return tileset()->columnCount();
     // TODO: Non-table tilesets should use a different model.
     // For now use an arbitrary number of columns.
     return 5;
 }
 
+QModelIndex TilesetModel::index(int row, int column, const QModelIndex &parent) const
+{
+    if (tileset()->isAtlas() && mColumnCountOverride <= 0)
+        return createIndex(row, column);
+
+    return QAbstractListModel::index(row, column, parent);
+}
+
 QVariant TilesetModel::data(const QModelIndex &index, int role) const
 {
     if (role == Qt::DecorationRole) {
@@ -126,62 +107,15 @@ QVariant TilesetModel::headerData(int /* section */,
     return QVariant();
 }
 
-QSize TilesetModel::tileSpanSize(const QModelIndex &index) const
-{
-    if (!tileset()->isAtlas())
-        return QSize(1, 1);
-
-    if (Tile *tile = tileAt(index)) {
-        const int tileWidth = tileset()->tileWidth();
-        const int tileHeight = tileset()->tileHeight();
-        const QRect rect = tile->imageRect();
-        return QSize(
-            rect.width() / tileWidth,
-            rect.height() / tileHeight
-        );
-    }
-
-    return QSize(1, 1);
-}
-
-Tile *TilesetModel::findSpanningTile(const QModelIndex &index) const
-{
-    if (!tileset()->isAtlas())
-        return nullptr;
-
-    for (Tile *tile : tileset()->tiles()) {
-        // Use tileIndex to get normalized grid position
-        QModelIndex tilePos = tileIndex(tile);
-        QSize span = tileSpanSize(tilePos);
-
-        if (span.width() <= 1 && span.height() <= 1)
-            continue;
-
-        if (index.row() >= tilePos.row() && index.row() < tilePos.row() + span.height() &&
-            index.column() >= tilePos.column() && index.column() < tilePos.column() + span.width()) {
-            return tile;
-        }
-    }
-
-    return nullptr;
-}
-
 Qt::ItemFlags TilesetModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags defaultFlags = QAbstractListModel::flags(index);
 
-    if (tileset()->isAtlas()) {
-        if (!index.isValid())
-            return defaultFlags;
-
-        // If this cell contains a tile's origin or we are relocating, it's selectable
-        if (mRelocating || tileAt(index))
-            return defaultFlags | Qt::ItemIsSelectable;
-
+    if (tileset()->isAtlas() && mColumnCountOverride <= 0 && index.column() == 0 && index.row() == 0)
         return defaultFlags & ~Qt::ItemIsSelectable;
-    }
 
     defaultFlags |= Qt::ItemIsDropEnabled;
+
     if (index.isValid())
         defaultFlags |= Qt::ItemIsDragEnabled;
 
@@ -273,26 +207,32 @@ Tile *TilesetModel::tileAt(const QModelIndex &index) const
     if (!index.isValid())
         return nullptr;
 
-    if (tileset()->isAtlas()) {
-        const QPoint atlasPos = viewToAtlasCoords(index.column(), index.row());
-        return mTileGrid.value(atlasPos);
+    if (tileset()->isAtlas() && mColumnCountOverride <= 0) {
+        const QPoint gridPos(index.column() - 1, index.row());
+        for (Tile *tile : tileset()->tiles()) {
+            const QPoint snappedPos = snapToGrid(tile->imageRect().bottomLeft());
+            if (snappedPos == gridPos)
+                return tile;
+        }
+
+        return nullptr;
     }
 
     const int tileIndex = index.column() + index.row() * columnCount();
     if (tileIndex < mTileIds.size()) {
         const int tileId = mTileIds.at(tileIndex);
         return tileset()->findTile(tileId);
     }
+
     return nullptr;
 }
 
 QModelIndex TilesetModel::tileIndex(const Tile *tile) const
 {
     Q_ASSERT(tile->tileset() == tileset());
-    if (tileset()->isAtlas()) {
-        const QPoint tilePos = tileset()->pixelToGrid(tile->imageRect().topLeft());
-        const QPoint viewPos = atlasToViewCoords(tilePos.x(), tilePos.y());
-        return index(viewPos.y(), viewPos.x());
+    if (tileset()->isAtlas() && mColumnCountOverride <= 0) {
+        const QPoint snappedPos = snapToGrid(tile->imageRect().bottomLeft());
+        return index(snappedPos.y(), snappedPos.x() + 1);
     }
 
     const int columnCount = TilesetModel::columnCount();
@@ -365,26 +305,24 @@ void TilesetModel::tilesChanged(const QList<Tile *> &tiles)
 
 void TilesetModel::tileChanged(Tile *tile)
 {
-    if (tileset()->isAtlas()) {
-        const QPoint oldPos = mTileGrid.key(tile, QPoint(-1, -1));
-        if (oldPos != QPoint(-1, -1))
-            mTileGrid.remove(oldPos);
-        const QPoint newPos = tileset()->pixelToGrid(tile->imageRect().topLeft());
-        mTileGrid.insert(newPos, tile);
-    }
-
     const QModelIndex i = tileIndex(tile);
     emit dataChanged(i, i);
 }
 
 void TilesetModel::refreshTileIds()
 {
     mTileIds.clear();
-    for (Tile *tile : tileset()->tiles()) {
+    for (Tile *tile : tileset()->tiles())
         mTileIds.append(tile->id());
-        const QPoint pos = tileset()->pixelToGrid(tile->imageRect().topLeft());
-        mTileGrid.insert(pos, tile);
-    }
+}
+
+QPoint TilesetModel::snapToGrid(const QPoint &pos) const
+{
+    const int tileWidth = tileset()->tileWidth();
+    const int tileHeight = tileset()->tileHeight();
+    const int x = (pos.x() + tileWidth / 2) / tileWidth;
+    const int y = (pos.y() + tileHeight / 2) / tileHeight;
+    return QPoint(x, y);
 }
 
 #include "moc_tilesetmodel.cpp"

src/tiled/tilesetmodel.h

@@ -80,6 +80,8 @@ class TilesetModel : public QAbstractListModel
                       int row, int column,
                       const QModelIndex &parent) override;
 
+    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
+
     /**
      * Returns the tile at the given index.
      */
@@ -104,11 +106,6 @@ class TilesetModel : public QAbstractListModel
 
     void setColumnCountOverride(int columnCount);
 
-    void setRelocating(bool relocating) { mRelocating = relocating; }
-
-    QSize tileSpanSize(const QModelIndex &index) const;
-    Tile *findSpanningTile(const QModelIndex &index) const;
-
 public slots:
     /**
      * Should be called when anything changes about the given \a tiles that
@@ -133,14 +130,11 @@ public slots:
 
     void refreshTileIds();
 
-    QPoint viewToAtlasCoords(int viewCol, int viewRow) const;
-    QPoint atlasToViewCoords(int atlasCol, int atlasRow) const;
+    QPoint snapToGrid(const QPoint &pos) const;
 
     TilesetDocument *mTilesetDocument;
     QList<int> mTileIds;
-    QHash<QPoint, Tile*> mTileGrid;
     int mColumnCountOverride = 0;
-    bool mRelocating = false;
 };
 
 } // namespace Tiled