Added layer properties: horizontal/vertical repeat, move speed, width, height

src/libtiled/layer.cpp

@@ -151,6 +151,9 @@ QPointF Layer::totalOffset() const
  */
 Layer *Layer::initializeClone(Layer *clone) const
 {
+    clone->mRepeatedY = mRepeatedY;
+    clone->mRepeatedX = mRepeatedX;
+    clone->mMoveSpeed = mMoveSpeed;
     clone->mOffset = mOffset;
     clone->mOpacity = mOpacity;
     clone->mVisible = mVisible;

src/libtiled/layer.h

@@ -154,6 +154,14 @@ class TILEDSHARED_EXPORT Layer : public Object
     void setOffset(const QPointF &offset);
     QPointF offset() const;
 
+    void setMoveSpeed(const QPointF &moveSpeed);
+    QPointF moveSpeed() const;
+
+    void setRepeatedX(const bool repeatX);
+    bool repeatedX() const;
+    void setRepeatedY(const bool repeatY);
+    bool repeatedY() const;
+
     QPointF totalOffset() const;
 
     virtual bool isEmpty() const = 0;
@@ -224,7 +232,10 @@ class TILEDSHARED_EXPORT Layer : public Object
     int mY;
     QPointF mOffset;
     float mOpacity;
+    QPointF mMoveSpeed;
     bool mVisible;
+    bool mRepeatedX;
+    bool mRepeatedY;
     Map *mMap;
     GroupLayer *mParentLayer;
 
@@ -249,6 +260,53 @@ inline QPointF Layer::offset() const
     return mOffset;
 }
 
+/**
+ * Sets the movement speed multiplier of this layer.
+ */
+inline void Layer::setMoveSpeed(const QPointF &moveSpeed)
+{
+    mMoveSpeed = moveSpeed;
+}
+
+/**
+ * Returns the movement speed multiplier of this layer.
+ */
+inline QPointF Layer::moveSpeed() const
+{
+    return mMoveSpeed;
+}
+
+/**
+ * Sets this layer to be repeated horizontally or not.
+ */
+inline void Layer::setRepeatedX(const bool repeatX)
+{
+    mRepeatedX = repeatX;
+}
+
+/**
+ * Sets this layer to be repeated vertically or not.
+ */
+inline void Layer::setRepeatedY(const bool repeatY)
+{
+    mRepeatedY = repeatY;
+}
+
+/**
+ * Returns true if this layer is repeated horizontally.
+ */
+inline bool Layer::repeatedX() const
+{
+    return mRepeatedX;
+}
+
+/**
+ * Returns true if this layer is repeated vertically.
+ */
+inline bool Layer::repeatedY() const
+{
+    return mRepeatedY;
+}
 
 /**
  * An iterator for iterating over the layers of a map. When iterating forward,

src/libtiled/mapreader.cpp

@@ -582,7 +582,16 @@ static void readLayerAttributes(Layer &layer,
     const QPointF offset(atts.value(QLatin1String("offsetx")).toDouble(),
                          atts.value(QLatin1String("offsety")).toDouble());
 
+    QPointF moveSpeed(atts.value(QLatin1String("moveSpeedX")).toDouble(),
+                      atts.value(QLatin1String("moveSpeedY")).toDouble());
+
+    const bool repeatX = atts.value(QLatin1String("repeatedX")).toInt();
+    const bool repeatY = atts.value(QLatin1String("repeatedY")).toInt();
+
     layer.setOffset(offset);
+    layer.setMoveSpeed(moveSpeed);
+    layer.setRepeatedX(repeatX);
+    layer.setRepeatedY(repeatY);
 }
 
 TileLayer *MapReaderPrivate::readTileLayer()

src/libtiled/maptovariantconverter.cpp

@@ -487,6 +487,15 @@ void MapToVariantConverter::addLayerAttributes(QVariantMap &layerVariant,
         layerVariant[QLatin1String("offsety")] = offset.y();
     }
 
+    const QPointF moveSpeed = layer.moveSpeed();
+    const QPointF neutral(1.0, 1.0);
+    if (moveSpeed!=neutral) {
+        layerVariant[QLatin1String("moveSpeedX")] = moveSpeed.x();
+        layerVariant[QLatin1String("moveSpeedY")] = moveSpeed.y();
+    }
+    layerVariant[QLatin1String("repeatedX")] = layer.repeatedX();
+    layerVariant[QLatin1String("repeatedY")] = layer.repeatedY();
+
     addProperties(layerVariant, layer.properties());
 }
 

src/libtiled/mapwriter.cpp

@@ -543,6 +543,16 @@ void MapWriterPrivate::writeLayerAttributes(QXmlStreamWriter &w,
         w.writeAttribute(QLatin1String("offsetx"), QString::number(offset.x()));
         w.writeAttribute(QLatin1String("offsety"), QString::number(offset.y()));
     }
+    const QPointF moveSpeed = layer.moveSpeed();
+    const QPointF neutral(1.0, 1.0);
+    if (moveSpeed!=neutral) {
+        w.writeAttribute(QLatin1String("moveSpeedX"), QString::number(moveSpeed.x()));
+        w.writeAttribute(QLatin1String("moveSpeedY"), QString::number(moveSpeed.y()));
+    }
+    if (layer.repeatedX())
+        w.writeAttribute(QLatin1String("repeatedX"), QLatin1String("1"));
+    if (layer.repeatedY())
+        w.writeAttribute(QLatin1String("repeatedY"), QLatin1String("1"));
 }
 
 void MapWriterPrivate::writeObjectGroup(QXmlStreamWriter &w,

src/libtiled/orthogonalrenderer.cpp

@@ -229,6 +229,11 @@ void OrthogonalRenderer::drawTileLayer(QPainter *painter,
     int endX = layer->width() - 1;
     int endY = layer->height() - 1;
 
+    if(layer->repeatedX())
+        endX = map()->width();
+    if(layer->repeatedY())
+        endY = map()->height();
+
     if (!exposed.isNull()) {
         QMargins drawMargins = layer->drawMargins();
         drawMargins.setTop(drawMargins.top() - tileHeight);
@@ -241,10 +246,14 @@ void OrthogonalRenderer::drawTileLayer(QPainter *painter,
 
         rect.translate(-layerPos);
 
-        startX = qMax(qFloor(rect.x() / tileWidth), 0);
-        startY = qMax(qFloor(rect.y() / tileHeight), 0);
-        endX = qMin(qCeil(rect.right()) / tileWidth, endX);
-        endY = qMin(qCeil(rect.bottom()) / tileHeight, endY);
+        if (!layer->repeatedX()) {
+            startX = qMax(qFloor(rect.x() / tileWidth), 0);
+            endX = qMin(qCeil(rect.right()) / tileWidth, endX);
+        }
+        if (!layer->repeatedY()) {
+            startY = qMax(qFloor(rect.y() / tileHeight), 0);
+            endY = qMin(qCeil(rect.bottom()) / tileHeight, endY);
+        }
     }
 
     // Return immediately when there is nothing to draw

src/libtiled/tilelayer.cpp

@@ -112,6 +112,16 @@ QRegion TileLayer::region(std::function<bool (const Cell &)> condition) const
  */
 void Tiled::TileLayer::setCell(int x, int y, const Cell &cell)
 {
+    if (repeatedX()) {
+        x %= width();
+        if(x<0)
+            x+= width();
+    }
+    if (repeatedY()) {
+        y %= height();
+        if(y<0)
+            y+= height();
+    }
     Q_ASSERT(contains(x, y));
 
     Cell &existingCell = mGrid[x + y * mWidth];

src/libtiled/tilelayer.h

@@ -380,6 +380,16 @@ inline QRegion TileLayer::region() const
  */
 inline const Cell &TileLayer::cellAt(int x, int y) const
 {
+    if (repeatedX()) {
+        x %= width();
+        if(x<0)
+            x+= width();
+    }
+    if (repeatedY()) {
+        y %= height();
+        if(x<0)
+            y+= height();
+    }
     Q_ASSERT(contains(x, y));
     return mGrid.at(x + y * mWidth);
 }

src/libtiled/varianttomapconverter.cpp

@@ -340,6 +340,13 @@ Layer *VariantToMapConverter::toLayer(const QVariant &variant)
         const QPointF offset(variantMap[QLatin1String("offsetx")].toDouble(),
                              variantMap[QLatin1String("offsety")].toDouble());
         layer->setOffset(offset);
+
+        const QPointF moveSpeed(variantMap[QLatin1String("moveSpeedX")].toDouble(),
+                             variantMap[QLatin1String("moveSpeedY")].toDouble());
+        layer->setMoveSpeed(moveSpeed);
+
+        layer->setRepeatedX(variantMap[QLatin1String("repeatedX")].toBool());
+        layer->setRepeatedY(variantMap[QLatin1String("repeatedY")].toBool());
     }
 
     return layer;

src/tiled/changelayer.cpp

@@ -101,6 +101,68 @@ void SetLayerOffset::setOffset(const QPointF &offset)
     mMapDocument->layerModel()->setLayerOffset(mLayer, offset);
 }
 
+SetLayerMoveSpeed::SetLayerMoveSpeed(MapDocument *mapDocument,
+                               Layer *layer,
+                               const QPointF &moveSpeed,
+                               QUndoCommand *parent)
+    : QUndoCommand(parent)
+    , mMapDocument(mapDocument)
+    , mLayer(layer)
+    , mOldOffset(layer->moveSpeed())
+    , mNewOffset(moveSpeed)
+{
+    setText(QCoreApplication::translate("Undo Commands",
+                                        "Change Layer Move Speed"));
+}
+
+void SetLayerMoveSpeed::setMoveSpeed(const QPointF &moveSpeed)
+{
+    mMapDocument->layerModel()->setLayerMoveSpeed(mLayer, moveSpeed);
+}
+
+SetLayerRepeatedX::SetLayerRepeatedX(MapDocument *mapDocument,
+                                 Layer *layer,
+                                 bool repeatedX)
+    : mMapDocument(mapDocument)
+    , mLayer(layer)
+    , mRepeatedX(repeatedX)
+{
+    if (repeatedX)
+        setText(QCoreApplication::translate("Undo Commands",
+                                            "Repeat Horizontally"));
+    else
+        setText(QCoreApplication::translate("Undo Commands",
+                                            "Dont Repeat Horizontally"));
+}
+
+void SetLayerRepeatedX::swap()
+{
+    const bool previousRepeatX = mLayer->repeatedX();
+    mMapDocument->layerModel()->setLayerRepeatedX(mLayer, mRepeatedX);
+    mRepeatedX = previousRepeatX;
+}
+
+SetLayerRepeatedY::SetLayerRepeatedY(MapDocument *mapDocument,
+                                 Layer *layer,
+                                 bool repeatedY)
+    : mMapDocument(mapDocument)
+    , mLayer(layer)
+    , mRepeatedY(repeatedY)
+{
+    if (repeatedY)
+        setText(QCoreApplication::translate("Undo Commands",
+                                            "Repeat Vertically"));
+    else
+        setText(QCoreApplication::translate("Undo Commands",
+                                            "Dont Repeat Vertically"));
+}
+
+void SetLayerRepeatedY::swap()
+{
+    const bool previousRepeatY = mLayer->repeatedY();
+    mMapDocument->layerModel()->setLayerRepeatedY(mLayer, mRepeatedY);
+    mRepeatedY = previousRepeatY;
+}
 
 } // namespace Internal
 } // namespace Tiled

src/tiled/changelayer.h

@@ -105,5 +105,72 @@ class SetLayerOffset : public QUndoCommand
     QPointF mNewOffset;
 };
 
+/**
+ * Used for changing the layer move speed.
+ */
+class SetLayerMoveSpeed : public QUndoCommand
+{
+public:
+    SetLayerMoveSpeed(MapDocument *mapDocument,
+                   Layer *layer,
+                   const QPointF &offset,
+                   QUndoCommand *parent = nullptr);
+
+    void undo() override { setMoveSpeed(mOldOffset); }
+    void redo() override { setMoveSpeed(mNewOffset); }
+
+    int id() const override { return Cmd_ChangeLayerOffset; }
+
+private:
+    void setMoveSpeed(const QPointF &moveSpeed);
+
+    MapDocument *mMapDocument;
+    Layer *mLayer;
+    QPointF mOldOffset;
+    QPointF mNewOffset;
+};
+
+/**
+ * Used for changing layer horizontal repetition.
+ */
+class SetLayerRepeatedX : public QUndoCommand
+{
+public:
+    SetLayerRepeatedX(MapDocument *mapDocument,
+                    Layer *layer,
+                    bool repeatedX);
+
+    void undo() override { swap(); }
+    void redo() override { swap(); }
+
+private:
+    void swap();
+
+    MapDocument *mMapDocument;
+    Layer *mLayer;
+    bool mRepeatedX;
+};
+
+/**
+ * Used for changing layer vertical repetition.
+ */
+class SetLayerRepeatedY : public QUndoCommand
+{
+public:
+    SetLayerRepeatedY(MapDocument *mapDocument,
+                    Layer *layer,
+                    bool repeatedY);
+
+    void undo() override { swap(); }
+    void redo() override { swap(); }
+
+private:
+    void swap();
+
+    MapDocument *mMapDocument;
+    Layer *mLayer;
+    bool mRepeatedY;
+};
+
 } // namespace Internal
 } // namespace Tiled