Add tileset tile x/y draw offset.

src/libtiled/map.cpp

@@ -39,6 +39,8 @@
 
 #include <QtMath>
 
+#include "qtcompat_p.h"
+
 using namespace Tiled;
 
 Map::Map()
@@ -100,11 +102,10 @@ void Map::adjustBoundingRectForOffsetsAndImageLayers(QRect &boundingRect) const
             // rect. More precise would be to take into account their
             // contents.
             const QPointF offset = layer->totalOffset();
-            offsetMargins = maxMargins(QMargins(qCeil(-offset.x()),
-                                                qCeil(-offset.y()),
-                                                qCeil(offset.x()),
-                                                qCeil(offset.y())),
-                                       offsetMargins);
+            offsetMargins = offsetMargins | QMargins(qCeil(-offset.x()),
+                                                     qCeil(-offset.y()),
+                                                     qCeil(offset.x()),
+                                                     qCeil(offset.y()));
             break;
         }
         case Layer::ImageLayerType: {
@@ -150,12 +151,7 @@ void Map::recomputeDrawMargins() const
         maxTileSize = std::max(maxTileSize, std::max(tileSize.width(),
                                                      tileSize.height()));
 
-        const QPoint offset = tileset->tileOffset();
-        offsetMargins = maxMargins(QMargins(-offset.x(),
-                                            -offset.y(),
-                                            offset.x(),
-                                            offset.y()),
-                                   offsetMargins);
+        offsetMargins = offsetMargins | tileset->drawMargins();
     }
 
     // We subtract the tile size of the map, since that part does not

src/libtiled/mapobject.cpp

@@ -256,16 +256,16 @@ Alignment MapObject::alignment(const Map *map) const
     if (Tileset *tileset = mCell.tileset())
         alignment = tileset->objectAlignment();
 
-    if (!map && mObjectGroup)
-        map = mObjectGroup->map();
-
     if (alignment == Unspecified) {
+        if (!map && mObjectGroup)
+            map = mObjectGroup->map();
+
         if (mCell.isEmpty())
-            return TopLeft;
+            alignment = TopLeft;
         else if (map && map->orientation() == Map::Isometric)
-            return Bottom;
-
-        return BottomLeft;
+            alignment = Bottom;
+        else
+            alignment = BottomLeft;
     }
 
     return alignment;

src/libtiled/mapreader.cpp

@@ -537,6 +537,11 @@ void MapReaderPrivate::readTilesetTile(Tileset &tileset)
     if (!probability.isEmpty())
         tile->setProbability(probability.toDouble());
 
+    // Read local tile offset
+    const QPoint origin(atts.value(QLatin1String("originx")).toInt(),
+                        atts.value(QLatin1String("originy")).toInt());
+    tile->setOrigin(origin);
+
     while (xml.readNextStartElement()) {
         if (xml.name() == QLatin1String("properties")) {
             tile->mergeProperties(readProperties());

src/libtiled/mapwriter.cpp

@@ -288,6 +288,8 @@ static bool includeTile(const Tile *tile)
         return true;
     if (tile->isAnimated())
         return true;
+    if (!tile->origin().isNull())
+        return true;
     if (tile->probability() != 1.0)
         return true;
 
@@ -449,6 +451,11 @@ void MapWriterPrivate::writeTileset(QXmlStreamWriter &w, const Tileset &tileset,
                 w.writeAttribute(FileFormat::classPropertyNameForObject(), tile->className());
             if (tile->probability() != 1.0)
                 w.writeAttribute(QStringLiteral("probability"), QString::number(tile->probability()));
+            const QPoint origin = tile->origin();
+            if (origin.x() != 0)
+                w.writeAttribute(QStringLiteral("originx"), QString::number(origin.x()));
+            if (origin.y() != 0)
+                w.writeAttribute(QStringLiteral("originy"), QString::number(origin.y()));
             if (!tile->properties().isEmpty())
                 writeProperties(w, tile->properties());
             if (isCollection) {

src/libtiled/qtcompat_p.h

@@ -30,3 +30,11 @@ using ::endl;
 #if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
 using QStringRef = QStringView;
 #endif
+
+#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
+constexpr inline QMargins operator|(const QMargins &m1, const QMargins &m2) noexcept
+{
+    return QMargins(qMax(m1.left(), m2.left()), qMax(m1.top(), m2.top()),
+                    qMax(m1.right(), m2.right()), qMax(m1.bottom(), m2.bottom()));
+}
+#endif

src/libtiled/tile.cpp

@@ -39,21 +39,15 @@ Tile::Tile(int id, Tileset *tileset):
     Object(TileType),
     mId(id),
     mTileset(tileset),
-    mImageStatus(LoadingReady),
-    mProbability(1.0),
-    mCurrentFrameIndex(0),
-    mUnusedTime(0)
+    mImageStatus(LoadingReady)
 {}
 
 Tile::Tile(const QPixmap &image, int id, Tileset *tileset):
     Object(TileType),
     mId(id),
     mTileset(tileset),
     mImage(image),
-    mImageStatus(image.isNull() ? LoadingError : LoadingReady),
-    mProbability(1.0),
-    mCurrentFrameIndex(0),
-    mUnusedTime(0)
+    mImageStatus(image.isNull() ? LoadingError : LoadingReady)
 {}
 
 Tile::~Tile()
@@ -150,11 +144,22 @@ void Tile::setImageRect(const QRect &imageRect)
 }
 
 /**
- * Returns the drawing offset of the tile (in pixels).
+ * Returns the total drawing offset of the tile (in pixels).
  */
 QPoint Tile::offset() const
 {
-    return mTileset->tileOffset();
+    return mTileset->tileOffset() - mOrigin;
+}
+
+/**
+ * Sets the origin of this tile (in pixels).
+ */
+void Tile::setOrigin(QPoint offset)
+{
+    mOrigin = offset;
+
+    if (mTileset)
+        mTileset->invalidateDrawMargins();
 }
 
 /**
@@ -245,6 +250,7 @@ Tile *Tile::clone(Tileset *tileset) const
 
     c->mImageSource = mImageSource;
     c->mImageRect = mImageRect;
+    c->mOrigin = mOrigin;
     c->mImageStatus = mImageStatus;
     c->mProbability = mProbability;
 

src/libtiled/tile.h

@@ -91,9 +91,12 @@ class TILEDSHARED_EXPORT Tile : public Object
 
     QPoint offset() const;
 
+    QPoint origin() const;
+    void setOrigin(QPoint offset);
+
     // For Python API compatibility
     const QString &type() const { return className(); }
-    void setType(const QString &type) { setClassName(type); };
+    void setType(const QString &type) { setClassName(type); }
 
     qreal probability() const;
     void setProbability(qreal probability);
@@ -121,13 +124,14 @@ class TILEDSHARED_EXPORT Tile : public Object
     mutable std::optional<QPainterPath> mImageShape;   // cache
     QUrl mImageSource;
     QRect mImageRect;
+    QPoint mOrigin;
     LoadingStatus mImageStatus;
-    qreal mProbability;
+    qreal mProbability = 1.0;
     std::unique_ptr<ObjectGroup> mObjectGroup;
 
     QVector<Frame> mFrames;
-    int mCurrentFrameIndex;
-    int mUnusedTime;
+    int mCurrentFrameIndex = 0;
+    int mUnusedTime = 0;
 
     friend class Tileset; // To allow changing the tile id
 };
@@ -195,6 +199,14 @@ inline QSize Tile::size() const
     return mImageRect.size();
 }
 
+/**
+ * Returns the origin of the tile (in pixels).
+ */
+inline QPoint Tile::origin() const
+{
+    return mOrigin;
+}
+
 /**
  * Returns the relative probability of this tile appearing while painting.
  */

src/libtiled/tiled.h

@@ -112,19 +112,6 @@ inline QString colorToString(const QColor &color)
     return color.name();
 }
 
-inline QMargins maxMargins(const QMargins &a,
-                           const QMargins &b)
-{
-#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
-    return QMargins(qMax(a.left(), b.left()),
-                    qMax(a.top(), b.top()),
-                    qMax(a.right(), b.right()),
-                    qMax(a.bottom(), b.bottom()));
-#else
-    return a | b;
-#endif
-}
-
 TILEDSHARED_EXPORT QString alignmentToString(Alignment);
 TILEDSHARED_EXPORT Alignment alignmentFromString(const QString &);
 

src/libtiled/tilelayer.cpp

@@ -38,6 +38,8 @@
 
 #include <QSet>
 
+#include "qtcompat_p.h"
+
 using namespace Tiled;
 
 Cell Cell::empty;
@@ -147,19 +149,13 @@ static QMargins computeDrawMargins(const QSet<SharedTileset> &tilesets)
     QMargins offsetMargins;
 
     for (const SharedTileset &tileset : tilesets) {
-        const QPoint offset = tileset->tileOffset();
-
         if (tileset->tileRenderSize() == Tileset::TileSize) {
             const QSize tileSize = tileset->tileSize();
             maxTileSize = std::max(maxTileSize, std::max(tileSize.width(),
                                                          tileSize.height()));
         }
 
-        offsetMargins = maxMargins(QMargins(-offset.x(),
-                                            -offset.y(),
-                                            offset.x(),
-                                            offset.y()),
-                                   offsetMargins);
+        offsetMargins = offsetMargins | tileset->drawMargins();
     }
 
     // Adding maxTileSize to top-right of the margins assumes a bottom-left tile

src/libtiled/tileset.cpp

@@ -36,6 +36,8 @@
 
 #include <QBitmap>
 
+#include "qtcompat_p.h"
+
 namespace Tiled {
 
 Tileset::Tileset(QString name, int tileWidth, int tileHeight,
@@ -103,6 +105,36 @@ void Tileset::setMargin(int margin)
     mMargin = margin;
 }
 
+/**
+ * @see tileOffset
+ */
+void Tileset::setTileOffset(QPoint offset)
+{
+    if (mTileOffset == offset)
+        return;
+
+    mTileOffset = offset;
+    mDrawMarginsDirty = true;
+}
+
+QMargins Tileset::drawMargins() const
+{
+    if (mDrawMarginsDirty) {
+        QMargins margins;
+
+        for (const Tile *tile : mTiles) {
+            const auto offset = mTileOffset - tile->origin();
+            margins = margins | QMargins(-offset.x(), -offset.y(),
+                                         offset.x(), offset.y());
+        }
+
+        mDrawMargins = margins;
+        mDrawMarginsDirty = false;
+    }
+
+    return mDrawMargins;
+}
+
 /**
  * Returns the location of the tile with the given ID.
  */

src/libtiled/tileset.h

@@ -162,6 +162,9 @@ class TILEDSHARED_EXPORT Tileset : public Object, public QEnableSharedFromThis<T
     QPoint tileOffset() const;
     void setTileOffset(QPoint offset);
 
+    QMargins drawMargins() const;
+    void invalidateDrawMargins();
+
     Orientation orientation() const;
     void setOrientation(Orientation orientation);
 
@@ -324,6 +327,9 @@ class TILEDSHARED_EXPORT Tileset : public Object, public QEnableSharedFromThis<T
     QString mFormat;
     TransformationFlags mTransformationFlags;
 
+    mutable QMargins mDrawMargins;
+    mutable bool mDrawMarginsDirty = true;
+
     QWeakPointer<Tileset> mOriginalTileset;
 };
 
@@ -454,12 +460,9 @@ inline QPoint Tileset::tileOffset() const
     return mTileOffset;
 }
 
-/**
- * @see tileOffset
- */
-inline void Tileset::setTileOffset(QPoint offset)
+inline void Tileset::invalidateDrawMargins()
 {
-    mTileOffset = offset;
+    mDrawMarginsDirty = true;
 }
 
 /**

src/libtiledquick/tilelayeritem.cpp

@@ -178,8 +178,8 @@ QSGNode *TileLayerItem::updatePaintNode(QSGNode *node,
 //            return;
 //        }
 
-        const auto offset = tileset->tileOffset();
         const auto tile = tileset->findTile(cell.tileId());
+        const auto offset = tile ? tile->offset() : tileset->tileOffset();
         const QSize size = (tile && !tile->image().isNull()) ? tile->size() : mRenderer->map()->tileSize();
 
         TileData data;
@@ -272,7 +272,7 @@ QSGNode *TileItem::updatePaintNode(QSGNode *node, QQuickItem::UpdatePaintNodeDat
         const int tileHeight = map->tileHeight();
 
         const QSize size = tile->size();
-        const QPoint offset = tileset->tileOffset();
+        const QPoint offset = tile->offset();
 
         QVector<TileData> data(1);
         data[0].x = mPosition.x() * tileWidth + offset.x();

src/plugins/lua/luaplugin.cpp

@@ -305,6 +305,8 @@ static bool includeTile(const Tile *tile)
         return true;
     if (tile->isAnimated())
         return true;
+    if (!tile->origin().isNull())
+        return true;
     if (tile->probability() != 1.0)
         return true;
 
@@ -434,6 +436,14 @@ void LuaWriter::writeTileset(const Tileset &tileset,
             }
         }
 
+        const QPoint origin = tile->origin();
+        if (!origin.isNull()) {
+            mWriter.writeStartTable("origin");
+            mWriter.writeKeyAndValue("x", origin.x());
+            mWriter.writeKeyAndValue("y", origin.y());
+            mWriter.writeEndTable();
+        }
+
         if (tile->probability() != 1.0)
             mWriter.writeKeyAndValue("probability", tile->probability());