Add option to invert Y-axis

src/libtiled/map.cpp

@@ -69,6 +69,24 @@ Map::~Map()
     qDeleteAll(mLayers);
 }
 
+void Map::setInvertYAxis(bool invertYAxis)
+{
+    mParameters.invertYAxis = invertYAxis;
+
+    for (auto layer : mLayers) {
+        if (!layer->isObjectGroup())
+            continue;
+
+        auto og = layer->asObjectGroup();
+        for (auto it = og->begin(); it != og->end(); ++it) {
+            auto object = *it;
+            // Tile objects are anchored in the lower-left already, so don't height-adjust
+            if (!object->isTileObject())
+                object->setY(object->y() + object->height() * (invertYAxis ? 1 : -1));
+        }
+    }
+}
+
 /**
  * Returns the margins that have to be taken into account when figuring
  * out which part of the map to repaint after changing some tiles.

src/libtiled/map.h

@@ -81,6 +81,7 @@ class TILEDSHARED_EXPORT Map : public Object
         TileWidthProperty,
         TileHeightProperty,
         InfiniteProperty,
+        InvertYAxisProperty,
         HexSideLengthProperty,
         StaggerAxisProperty,
         StaggerIndexProperty,
@@ -158,6 +159,7 @@ class TILEDSHARED_EXPORT Map : public Object
         int tileWidth = 0;
         int tileHeight = 0;
         bool infinite = false;
+        bool invertYAxis = false;
         int hexSideLength = 0;
         StaggerAxis staggerAxis = StaggerY;
         StaggerIndex staggerIndex = StaggerOdd;
@@ -216,6 +218,9 @@ class TILEDSHARED_EXPORT Map : public Object
     bool infinite() const;
     void setInfinite(bool infinite);
 
+    bool invertYAxis() const;
+    void setInvertYAxis(bool invertYAxis);
+
     int hexSideLength() const;
     void setHexSideLength(int hexSideLength);
 
@@ -285,7 +290,7 @@ class TILEDSHARED_EXPORT Map : public Object
 
     QSize chunkSize() const;
     void setChunkSize(QSize size);
-    
+
     bool isTilesetUsed(const Tileset *tileset) const;
 
     std::unique_ptr<Map> clone() const;
@@ -465,6 +470,11 @@ inline void Map::setInfinite(bool infinite)
     mParameters.infinite = infinite;
 }
 
+inline bool Map::invertYAxis() const
+{
+    return mParameters.invertYAxis;
+}
+
 inline int Map::hexSideLength() const
 {
     return mParameters.hexSideLength;

src/libtiled/mapobject.cpp

@@ -30,7 +30,6 @@
 
 #include "mapobject.h"
 
-#include "map.h"
 #include "maprenderer.h"
 #include "objectgroup.h"
 #include "objecttemplate.h"
@@ -272,7 +271,7 @@ Alignment MapObject::alignment(const Map *map) const
 
     if (alignment == Unspecified) {
         if (mCell.isEmpty())
-            return TopLeft;
+            return map && map->invertYAxis() ? BottomLeft : TopLeft;
         else if (map && map->orientation() == Map::Isometric)
             return Bottom;
 

src/libtiled/mapobject.h

@@ -30,6 +30,7 @@
 
 #pragma once
 
+#include "map.h"
 #include "object.h"
 #include "tiled.h"
 #include "tilelayer.h"
@@ -316,7 +317,7 @@ inline qreal MapObject::y() const
 { return mPos.y(); }
 
 /**
- * Sets the x position of this object.
+ * Sets the y position of this object.
  */
 inline void MapObject::setY(qreal y)
 { mPos.setY(y); }

src/libtiled/mapreader.cpp

@@ -264,6 +264,7 @@ std::unique_ptr<Map> MapReaderPrivate::readMap()
     mapParameters.tileWidth = atts.value(QLatin1String("tilewidth")).toInt();
     mapParameters.tileHeight = atts.value(QLatin1String("tileheight")).toInt();
     mapParameters.infinite = atts.value(QLatin1String("infinite")).toInt();
+    mapParameters.invertYAxis = atts.value(QLatin1String("invertyaxis")).toInt();
     mapParameters.hexSideLength = atts.value(QLatin1String("hexsidelength")).toInt();
     mapParameters.staggerAxis = staggerAxisFromString(staggerAxis);
     mapParameters.staggerIndex = staggerIndexFromString(staggerIndex);
@@ -313,18 +314,23 @@ std::unique_ptr<Map> MapReaderPrivate::readMap()
                 tileset->loadImage();
         }
 
-        // Fix up sizes of tile objects. This is for backwards compatibility.
         LayerIterator iterator(mMap.get());
         while (Layer *layer = iterator.next()) {
             if (ObjectGroup *objectGroup = layer->asObjectGroup()) {
                 for (MapObject *object : *objectGroup) {
+                    // Fix up sizes of tile objects. This is for backwards compatibility.
                     if (const Tile *tile = object->cell().tile()) {
                         const QSizeF tileSize = tile->size();
                         if (object->width() == 0)
                             object->setWidth(tileSize.width());
                         if (object->height() == 0)
                             object->setHeight(tileSize.height());
                     }
+
+                    // Invert Y-axis if set
+                    if (mMap->invertYAxis())
+                        object->setY(mMap->height() * mMap->tileHeight() - object->y());
+
                 }
             }
         }

src/libtiled/maptovariantconverter.cpp

@@ -63,6 +63,7 @@ QVariant MapToVariantConverter::toVariant(const Map &map, const QDir &mapDir)
     mapVariant[QStringLiteral("tilewidth")] = map.tileWidth();
     mapVariant[QStringLiteral("tileheight")] = map.tileHeight();
     mapVariant[QStringLiteral("infinite")] = map.infinite();
+    mapVariant[QStringLiteral("invertyaxis")] = map.invertYAxis();
     mapVariant[QStringLiteral("nextlayerid")] = map.nextLayerId();
     mapVariant[QStringLiteral("nextobjectid")] = map.nextObjectId();
     mapVariant[QStringLiteral("compressionlevel")] = map.compressionLevel();

src/libtiled/mapwriter.cpp

@@ -211,6 +211,8 @@ void MapWriterPrivate::writeMap(QXmlStreamWriter &w, const Map &map)
                      QString::number(map.tileHeight()));
     w.writeAttribute(QStringLiteral("infinite"),
                      QString::number(map.infinite()));
+    w.writeAttribute(QStringLiteral("invertyaxis"),
+                     QString::number(map.invertYAxis()));
 
     if (map.orientation() == Map::Hexagonal) {
         w.writeAttribute(QStringLiteral("hexsidelength"),
@@ -784,7 +786,12 @@ void MapWriterPrivate::writeObject(QXmlStreamWriter &w,
 
     if (!mapObject.isTemplateBase()) {
         w.writeAttribute(QStringLiteral("x"), QString::number(pos.x()));
-        w.writeAttribute(QStringLiteral("y"), QString::number(pos.y()));
+
+        qreal y = pos.y();
+        if (mapObject.map()->invertYAxis())
+            y = mapObject.map()->height() * mapObject.map()->tileHeight() - y;
+
+        w.writeAttribute(QStringLiteral("y"), QString::number(y));
     }
 
     if (shouldWrite(true, isTemplateInstance, mapObject.propertyChanged(MapObject::SizeProperty))) {

src/libtiled/varianttomapconverter.cpp

@@ -77,6 +77,7 @@ std::unique_ptr<Map> VariantToMapConverter::toMap(const QVariant &variant,
     mapParameters.tileWidth = variantMap[QStringLiteral("tilewidth")].toInt();
     mapParameters.tileHeight = variantMap[QStringLiteral("tileheight")].toInt();
     mapParameters.infinite = variantMap[QStringLiteral("infinite")].toInt();
+    mapParameters.invertYAxis = variantMap[QStringLiteral("invertyaxis")].toInt();
     mapParameters.hexSideLength = variantMap[QStringLiteral("hexsidelength")].toInt();
     mapParameters.staggerAxis = staggerAxisFromString(staggerAxis);
     mapParameters.staggerIndex = staggerIndexFromString(staggerIndex);

src/plugins/lua/luaplugin.cpp

@@ -226,6 +226,7 @@ void LuaWriter::writeMap(const Map *map)
     mWriter.writeKeyAndValue("height", map->height());
     mWriter.writeKeyAndValue("tilewidth", map->tileWidth());
     mWriter.writeKeyAndValue("tileheight", map->tileHeight());
+    mWriter.writeKeyAndValue("invertyaxis", map->invertYAxis());
     mWriter.writeKeyAndValue("nextlayerid", map->nextLayerId());
     mWriter.writeKeyAndValue("nextobjectid", map->nextObjectId());
 

src/tiled/abstractobjecttool.cpp

@@ -39,6 +39,7 @@
 #include "tile.h"
 #include "tmxmapformat.h"
 #include "utils.h"
+#include "invertyaxishelper.h"
 
 #include <QFileDialog>
 #include <QGraphicsView>
@@ -185,7 +186,10 @@ void AbstractObjectTool::mouseMoved(const QPointF &pos,
     const QPointF tilePosF = mapDocument()->renderer()->screenToTileCoords(offsetPos);
     const int x = qFloor(tilePosF.x());
     const int y = qFloor(tilePosF.y());
-    setStatusInfo(QStringLiteral("%1, %2 (%3, %4)").arg(x).arg(y).arg(pixelPos.x()).arg(pixelPos.y()));
+    setStatusInfo(QStringLiteral("%1, %2 (%3, %4)").arg(x)
+                                                   .arg(InvertYAxisHelper(mapDocument()).tileY(y))
+                                                   .arg(pixelPos.x())
+                                                   .arg(InvertYAxisHelper(mapDocument()).pixelY(pixelPos.y())));
 }
 
 void AbstractObjectTool::mousePressed(QGraphicsSceneMouseEvent *event)

src/tiled/abstracttiletool.cpp

@@ -27,6 +27,7 @@
 #include "mapscene.h"
 #include "tilelayer.h"
 #include "tilestamp.h"
+#include "invertyaxishelper.h"
 
 #include <QKeyEvent>
 #include <QtMath>
@@ -196,7 +197,7 @@ void AbstractTileTool::updateStatusInfo()
 
         setStatusInfo(QStringLiteral("%1, %2 [%3]")
                       .arg(mTilePosition.x())
-                      .arg(mTilePosition.y())
+                      .arg(InvertYAxisHelper(mapDocument()).tileY(mTilePosition.y()))
                       .arg(tileIdString));
     } else {
         setStatusInfo(QString());

src/tiled/changemapproperty.cpp

@@ -48,6 +48,10 @@ ChangeMapProperty::ChangeMapProperty(MapDocument *mapDocument,
         setText(QCoreApplication::translate("Undo Commands",
                                             "Change Infinite Property"));
         break;
+    case Map::InvertYAxisProperty:
+        setText(QCoreApplication::translate("Undo Commands",
+                                            "Change Invert Y-Axis Property"));
+        break;
     case Map::HexSideLengthProperty:
         setText(QCoreApplication::translate("Undo Commands",
                                             "Change Hex Side Length"));
@@ -174,6 +178,12 @@ void ChangeMapProperty::swap()
         mIntValue = infinite;
         break;
     }
+    case Map::InvertYAxisProperty: {
+        const int invertYAxis = map->invertYAxis();
+        map->setInvertYAxis(mIntValue);
+        mIntValue = invertYAxis;
+        break;
+    }
     case Map::OrientationProperty: {
         const Map::Orientation orientation = map->orientation();
         map->setOrientation(mOrientation);

src/tiled/clipboardmanager.cpp

@@ -156,6 +156,7 @@ bool ClipboardManager::copySelection(const MapDocument &mapDocument)
     mapParameters.width = selectionBounds.width();
     mapParameters.height = selectionBounds.height();
     mapParameters.infinite = false;
+    mapParameters.invertYAxis = false;
     Map copyMap(mapParameters);
 
     if (!selectedArea.isEmpty()) {

src/tiled/editablemap.cpp

@@ -539,6 +539,14 @@ void EditableMap::setInfinite(bool value)
         map()->setInfinite(value);
 }
 
+void EditableMap::setInvertYAxis(bool value)
+{
+    if (auto doc = mapDocument())
+        push(new ChangeMapProperty(doc, Map::InvertYAxisProperty, value));
+    else if (!checkReadOnly())
+        map()->setInvertYAxis(value);
+}
+
 void EditableMap::setHexSideLength(int value)
 {
     if (auto doc = mapDocument())

src/tiled/editablemap.h

@@ -46,6 +46,7 @@ class EditableMap : public EditableAsset
     Q_PROPERTY(int tileWidth READ tileWidth WRITE setTileWidth)
     Q_PROPERTY(int tileHeight READ tileHeight WRITE setTileHeight)
     Q_PROPERTY(bool infinite READ infinite WRITE setInfinite)
+    Q_PROPERTY(bool invertYAxis READ invertYAxis WRITE setInvertYAxis)
     Q_PROPERTY(int hexSideLength READ hexSideLength WRITE setHexSideLength)
     Q_PROPERTY(StaggerAxis staggerAxis READ staggerAxis WRITE setStaggerAxis)
     Q_PROPERTY(StaggerIndex staggerIndex READ staggerIndex WRITE setStaggerIndex)
@@ -121,6 +122,7 @@ class EditableMap : public EditableAsset
     int tileWidth() const;
     int tileHeight() const;
     bool infinite() const;
+    bool invertYAxis() const;
     int hexSideLength() const;
     StaggerAxis staggerAxis() const;
     StaggerIndex staggerIndex() const;
@@ -184,6 +186,7 @@ class EditableMap : public EditableAsset
     void setTileHeight(int value);
     Q_INVOKABLE void setTileSize(int width, int height);
     void setInfinite(bool value);
+    void setInvertYAxis(bool value);
     void setHexSideLength(int value);
     void setStaggerAxis(StaggerAxis value);
     void setStaggerIndex(StaggerIndex value);
@@ -264,6 +267,11 @@ inline bool EditableMap::infinite() const
     return map()->infinite();
 }
 
+inline bool EditableMap::invertYAxis() const
+{
+    return map()->invertYAxis();
+}
+
 inline int EditableMap::hexSideLength() const
 {
     return map()->hexSideLength();

src/tiled/invertyaxishelper.h

@@ -0,0 +1,69 @@
+/*
+ * invertyaxishelper.h
+ * Copyright 2013, Thorbjørn Lindeijer <thorbjorn@lindeijer.nl>
+ * Copyright 2018, Adrian Frances <adrianfranceslillo@gmail.com>
+ *
+ * This file is part of Tiled.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "mapdocument.h"
+#include "maprenderer.h"
+#include "preferences.h"
+
+namespace Tiled {
+
+class InvertYAxisHelper
+{
+public:
+    InvertYAxisHelper(MapDocument *mapDocument)
+        : mMapDocument(mapDocument)
+    {}
+
+    int tileY(int y) const;
+    qreal pixelY(qreal y) const;
+
+private:
+    MapDocument *mMapDocument;
+};
+
+/**
+ * Inverts Y coordinate in tiles when applicable.
+ */
+inline int InvertYAxisHelper::tileY(int y) const
+{
+    // Check if Invert Y Axis is set
+    if (mMapDocument->map()->invertYAxis())
+        return mMapDocument->map()->height() - 1 - y;
+    return y;
+}
+
+/**
+ * Inverts Y coordinate in pixels when applicable.
+ */
+inline qreal InvertYAxisHelper::pixelY(qreal y) const
+{
+    // Obtain the map document
+    if (mMapDocument->map()->invertYAxis()) {
+        const MapRenderer *renderer = mMapDocument->renderer();
+        QRect boundingRect = renderer->boundingRect(QRect(QPoint(), mMapDocument->map()->size()));
+        return boundingRect.height() - y;
+    }
+    return y;
+}
+
+} // Namespace Tiled

src/tiled/mapobjectmodel.cpp

@@ -30,6 +30,7 @@
 #include "map.h"
 #include "mapdocument.h"
 #include "objectgroup.h"
+#include "invertyaxishelper.h"
 
 #include <QApplication>
 #include <QPalette>
@@ -165,7 +166,7 @@ QVariant MapObjectModel::data(const QModelIndex &index, int role) const
                 return QLatin1Char('(')
                         + QString::number(mapObject->x())
                         + QLatin1String(", ")
-                        + QString::number(mapObject->y())
+                        + QString::number(InvertYAxisHelper(mapDocument()).tileY(mapObject->y()))
                         + QLatin1Char(')');
             }
             break;