Add Repeat X and Repeat Y properties to Image Layers

Introduce the boolean properties "Repeat X" and "Repeat Y" to Image
Layers. For rendering inside Tiled, this repetition is limited to the
overall bounds of all tile layers.
As a result, drawing will be cut off when an offset is set along with
the repeating property for that axis.

The YY plugin will export these properties accordingly as
"Horizontal Tile" and "Vertical Tile".
For backwards compatibility however, the respective custom properties
"htiled" and "vtiled" take precedence over the built-in ones.

src/libtiled/imagelayer.h

@@ -114,6 +114,26 @@ class TILEDSHARED_EXPORT ImageLayer : public Layer
      */
     bool isEmpty() const override;
 
+    /**
+     * Returns true if the image of this layer repeats along the x axis.
+     */
+    bool repeatX() const { return mRepeatX; }
+
+    /**
+     * Returns true if the image of this layer repeats along the y axis.
+     */
+    bool repeatY() const { return mRepeatY; }
+
+    /**
+     * Sets whether the image of this layer repeats along the x axis.
+     */
+    void setRepeatX(bool repeatX) { mRepeatX = repeatX; }
+
+    /**
+     * Sets whether the image of this layer repeats along the y axis.
+     */
+    void setRepeatY(bool repeatY) { mRepeatY = repeatY; }
+
     ImageLayer *clone() const override;
 
 protected:
@@ -123,6 +143,8 @@ class TILEDSHARED_EXPORT ImageLayer : public Layer
     QUrl mImageSource;
     QColor mTransparentColor;
     QPixmap mImage;
+    bool mRepeatX = false;
+    bool mRepeatY = false;
 };
 
 } // namespace Tiled

src/libtiled/mapreader.cpp

@@ -1142,6 +1142,9 @@ std::unique_ptr<ImageLayer> MapReaderPrivate::readImageLayer()
     auto imageLayer = std::make_unique<ImageLayer>(name, x, y);
     readLayerAttributes(*imageLayer, atts);
 
+    imageLayer->setRepeatX(atts.value(QLatin1String("repeatx")).toInt());
+    imageLayer->setRepeatY(atts.value(QLatin1String("repeaty")).toInt());
+
     // Image layer pixel position moved from x/y to offsetx/offsety for
     // consistency with other layers. This is here for backwards compatibility.
     if (!atts.hasAttribute(QLatin1String("offsetx")))

src/libtiled/maprenderer.cpp

@@ -82,7 +82,18 @@ MapRenderer::~MapRenderer()
 
 QRectF MapRenderer::boundingRect(const ImageLayer *imageLayer) const
 {
-    return QRectF(QPointF(), imageLayer->image().size());
+    QRectF bounds = QRectF(QPointF(), imageLayer->image().size());
+
+    if (imageLayer->repeatX()) {
+        bounds.setLeft(INT_MIN / 512);
+        bounds.setRight(INT_MAX / 256);
+    }
+    if (imageLayer->repeatY()) {
+        bounds.setTop(INT_MIN / 512);
+        bounds.setBottom(INT_MAX / 256);
+    }
+
+    return bounds;
 }
 
 QPainterPath MapRenderer::pointShape(const QPointF &position) const
@@ -115,7 +126,10 @@ void MapRenderer::drawImageLayer(QPainter *painter,
 {
     Q_UNUSED(exposed)
 
-    painter->drawPixmap(QPointF(), tinted(imageLayer->image(), imageLayer->effectiveTintColor()));
+    painter->save();
+    painter->setBrush(tinted(imageLayer->image(), imageLayer->effectiveTintColor()));
+    painter->drawRect(boundingRect(imageLayer));
+    painter->restore();
 }
 
 void MapRenderer::drawPointObject(QPainter *painter, const QColor &color) const

src/libtiled/mapwriter.cpp

@@ -860,6 +860,9 @@ void MapWriterPrivate::writeImageLayer(QXmlStreamWriter &w,
     w.writeStartElement(QStringLiteral("imagelayer"));
     writeLayerAttributes(w, imageLayer);
 
+    w.writeAttribute(QStringLiteral("repeatx"), QString::number(imageLayer.repeatX()));
+    w.writeAttribute(QStringLiteral("repeaty"), QString::number(imageLayer.repeatY()));
+
     // Write the image element
     const QUrl &imageSource = imageLayer.imageSource();
     if (!imageSource.isEmpty()) {

src/plugins/yy/yyplugin.cpp

@@ -1164,8 +1164,10 @@ static std::unique_ptr<GMRLayer> processImageLayer(const ImageLayer *imageLayer)
     gmrBackgroundLayer->x = layerOffset.x();
     gmrBackgroundLayer->y = layerOffset.y();
 
-    gmrBackgroundLayer->htiled = optionalProperty(imageLayer, "htiled", gmrBackgroundLayer->htiled);
-    gmrBackgroundLayer->vtiled = optionalProperty(imageLayer, "vtiled", gmrBackgroundLayer->vtiled);
+    // Give custom properties priority to ensure backwards compatibility
+    gmrBackgroundLayer->htiled = optionalProperty(imageLayer, "htiled", imageLayer->repeatX());
+    gmrBackgroundLayer->vtiled = optionalProperty(imageLayer, "vtiled", imageLayer->repeatY());
+
     gmrBackgroundLayer->hspeed = optionalProperty(imageLayer, "hspeed", gmrBackgroundLayer->hspeed);
     gmrBackgroundLayer->vspeed = optionalProperty(imageLayer, "vspeed", gmrBackgroundLayer->vspeed);
     gmrBackgroundLayer->stretch = optionalProperty(imageLayer, "stretch", gmrBackgroundLayer->stretch);

src/tiled/changeimagelayerproperties.cpp

@@ -33,7 +33,9 @@ ChangeImageLayerProperties::ChangeImageLayerProperties(
         MapDocument *mapDocument,
         ImageLayer *imageLayer,
         const QColor &color,
-        const QUrl &newSource)
+        const QUrl &newSource,
+        bool newRepeatX,
+        bool newRepeatY)
     : QUndoCommand(
           QCoreApplication::translate(
               "Undo Commands", "Change Image Layer Properties"))
@@ -43,6 +45,10 @@ ChangeImageLayerProperties::ChangeImageLayerProperties(
     , mRedoColor(color)
     , mUndoSource(imageLayer->imageSource())
     , mRedoSource(newSource)
+    , mUndoRepeatX(imageLayer->repeatX())
+    , mRedoRepeatX(newRepeatX)
+    , mUndoRepeatY(imageLayer->repeatY())
+    , mRedoRepeatY(newRepeatY)
 {
 }
 
@@ -55,6 +61,9 @@ void ChangeImageLayerProperties::redo()
     else
         mImageLayer->loadFromImage(mRedoSource);
 
+    mImageLayer->setRepeatX(mRedoRepeatX);
+    mImageLayer->setRepeatY(mRedoRepeatY);
+
     emit mMapDocument->imageLayerChanged(mImageLayer);
 }
 
@@ -67,6 +76,9 @@ void ChangeImageLayerProperties::undo()
     else
         mImageLayer->loadFromImage(mUndoSource);
 
+    mImageLayer->setRepeatX(mUndoRepeatX);
+    mImageLayer->setRepeatY(mUndoRepeatY);
+
     emit mMapDocument->imageLayerChanged(mImageLayer);
 }
 

src/tiled/changeimagelayerproperties.h

@@ -42,11 +42,15 @@ class ChangeImageLayerProperties : public QUndoCommand
      * @param imageLayer    the image layer to modify
      * @param newColor      the new transparent color to apply
      * @param newSource     the new image source to apply
+     * @param newRepeatX    the new repetition along the x axis to apply
+     * @param newRepeatY    the new repetition along the y axis to apply
      */
     ChangeImageLayerProperties(MapDocument *mapDocument,
                                ImageLayer *imageLayer,
                                const QColor &newColor,
-                               const QUrl &newSource);
+                               const QUrl &newSource,
+                               bool newRepeatX,
+                               bool newRepeatY);
 
     void undo() override;
     void redo() override;
@@ -58,6 +62,10 @@ class ChangeImageLayerProperties : public QUndoCommand
     const QColor mRedoColor;
     const QUrl mUndoSource;
     const QUrl mRedoSource;
+    const bool mUndoRepeatX;
+    const bool mRedoRepeatX;
+    const bool mUndoRepeatY;
+    const bool mRedoRepeatY;
 };
 
 } // namespace Tiled

src/tiled/editableimagelayer.cpp

@@ -42,7 +42,9 @@ void EditableImageLayer::setTransparentColor(const QColor &transparentColor)
         asset()->push(new ChangeImageLayerProperties(doc,
                                                      imageLayer(),
                                                      transparentColor,
-                                                     imageSource()));
+                                                     imageSource(),
+                                                     repeatX(),
+                                                     repeatY()));
     } else {
         imageLayer()->setTransparentColor(transparentColor);
         if (!imageSource().isEmpty())
@@ -56,7 +58,9 @@ void EditableImageLayer::setImageSource(const QUrl &imageSource)
         asset()->push(new ChangeImageLayerProperties(doc,
                                                      imageLayer(),
                                                      transparentColor(),
-                                                     imageSource));
+                                                     imageSource,
+                                                     repeatX(),
+                                                     repeatY()));
     } else {
         if (imageSource.isEmpty())
             imageLayer()->resetImage();
@@ -71,6 +75,33 @@ void EditableImageLayer::setImage(ScriptImage *image, const QUrl &source)
     imageLayer()->loadFromImage(QPixmap::fromImage(image->image()), source);
 }
 
+void EditableImageLayer::setRepeatX(bool repeatX)
+{
+    if (auto doc = mapDocument()) {
+        asset()->push(new ChangeImageLayerProperties(doc,
+                                                     imageLayer(),
+                                                     transparentColor(),
+                                                     imageSource(),
+                                                     repeatX,
+                                                     repeatY()));
+    } else {
+        imageLayer()->setRepeatX(repeatX);
+    }
+}
+
+void EditableImageLayer::setRepeatY(bool repeatY)
+{
+    if (auto doc = mapDocument()) {
+        asset()->push(new ChangeImageLayerProperties(doc,
+                                                     imageLayer(),
+                                                     transparentColor(),
+                                                     imageSource(),
+                                                     repeatX(),
+                                                     repeatY));
+    } else {
+        imageLayer()->setRepeatY(repeatY);
+    }
+}
 } // namespace Tiled
 
 #include "moc_editableimagelayer.cpp"

src/tiled/editableimagelayer.h

@@ -33,6 +33,8 @@ class EditableImageLayer : public EditableLayer
 
     Q_PROPERTY(QColor transparentColor READ transparentColor WRITE setTransparentColor)
     Q_PROPERTY(QUrl imageSource READ imageSource WRITE setImageSource)
+    Q_PROPERTY(bool repeatX READ repeatX WRITE setRepeatX)
+    Q_PROPERTY(bool repeatY READ repeatY WRITE setRepeatY)
 
 public:
     Q_INVOKABLE explicit EditableImageLayer(const QString &name = QString(),
@@ -44,9 +46,13 @@ class EditableImageLayer : public EditableLayer
 
     const QColor &transparentColor() const;
     const QUrl &imageSource() const;
+    bool repeatX() const;
+    bool repeatY() const;
 
     void setTransparentColor(const QColor &transparentColor);
     void setImageSource(const QUrl &imageSource);
+    void setRepeatX(bool repeatX);
+    void setRepeatY(bool repeatY);
 
     Q_INVOKABLE void setImage(Tiled::ScriptImage *image, const QUrl &source = QUrl());
 
@@ -65,6 +71,16 @@ inline const QUrl &EditableImageLayer::imageSource() const
     return imageLayer()->imageSource();
 }
 
+inline bool EditableImageLayer::repeatX() const
+{
+    return imageLayer()->repeatX();
+}
+
+inline bool EditableImageLayer::repeatY() const
+{
+    return imageLayer()->repeatY();
+}
+
 inline ImageLayer *EditableImageLayer::imageLayer() const
 {
     return static_cast<ImageLayer*>(layer());

src/tiled/propertybrowser.cpp

@@ -781,6 +781,9 @@ void PropertyBrowser::addImageLayerProperties()
 
     addProperty(ColorProperty, QMetaType::QColor, tr("Transparent Color"), groupProperty);
 
+    addProperty(RepeatXProperty, QMetaType::Bool, tr("Repeat X"), groupProperty);
+    addProperty(RepeatYProperty, QMetaType::Bool, tr("Repeat Y"), groupProperty);
+
     addProperty(groupProperty);
 }
 
@@ -1278,19 +1281,53 @@ QUndoCommand *PropertyBrowser::applyImageLayerValueTo(PropertyId id, const QVari
     case ImageSourceProperty: {
         const FilePath imageSource = val.value<FilePath>();
         const QColor &color = imageLayer->transparentColor();
+        const bool repeatX = imageLayer->repeatX();
+        const bool repeatY = imageLayer->repeatY();
         command = new ChangeImageLayerProperties(mMapDocument,
                                                  imageLayer,
                                                  color,
-                                                 imageSource.url);
+                                                 imageSource.url,
+                                                 repeatX,
+                                                 repeatY);
         break;
     }
     case ColorProperty: {
         const QColor color = val.value<QColor>();
         const QUrl &imageSource = imageLayer->imageSource();
+        const bool repeatX = imageLayer->repeatX();
+        const bool repeatY = imageLayer->repeatY();
+        command = new ChangeImageLayerProperties(mMapDocument,
+                                                 imageLayer,
+                                                 color,
+                                                 imageSource,
+                                                 repeatX,
+                                                 repeatY);
+        break;
+    }
+    case RepeatXProperty: {
+        const bool repeatX = val.toBool();
+        const QUrl &imageSource = imageLayer->imageSource();
+        const QColor &color = imageLayer->transparentColor();
+        const bool repeatY = imageLayer->repeatY();
+        command = new ChangeImageLayerProperties(mMapDocument,
+                                                 imageLayer,
+                                                 color,
+                                                 imageSource,
+                                                 repeatX,
+                                                 repeatY);
+        break;
+    }
+    case RepeatYProperty: {
+        const bool repeatY = val.toBool();
+        const QUrl &imageSource = imageLayer->imageSource();
+        const QColor &color = imageLayer->transparentColor();
+        const bool repeatX = imageLayer->repeatX();
         command = new ChangeImageLayerProperties(mMapDocument,
                                                  imageLayer,
                                                  color,
-                                                 imageSource);
+                                                 imageSource,
+                                                 repeatX,
+                                                 repeatY);
         break;
     }
     default:
@@ -1766,6 +1803,8 @@ void PropertyBrowser::updateProperties()
             const ImageLayer *imageLayer = static_cast<const ImageLayer*>(layer);
             mIdToProperty[ImageSourceProperty]->setValue(QVariant::fromValue(FilePath { imageLayer->imageSource() }));
             mIdToProperty[ColorProperty]->setValue(imageLayer->transparentColor());
+            mIdToProperty[RepeatXProperty]->setValue(imageLayer->repeatX());
+            mIdToProperty[RepeatYProperty]->setValue(imageLayer->repeatY());
             break;
         }
         case Layer::GroupLayerType:

src/tiled/propertybrowser.h

@@ -114,6 +114,8 @@ class PropertyBrowser : public QtTreePropertyBrowser
         OffsetXProperty,
         OffsetYProperty,
         ParallaxFactorProperty,
+        RepeatXProperty,
+        RepeatYProperty,
         ColorProperty,
         BackgroundColorProperty,
         TileWidthProperty,