bool TmxViewer::viewMap(const QString &fileName)
{
mScene->clear();
centerOn(0, 0);
mRenderer.reset();
MapReader reader;
mMap.reset(reader.readMap(fileName));
if (!mMap) {
qWarning().noquote() << "Error:" << reader.errorString();
return false;
}
switch (mMap->orientation()) {
case Map::Isometric:
mRenderer.reset(new IsometricRenderer(mMap.get()));
break;
case Map::Staggered:
mRenderer.reset(new StaggeredRenderer(mMap.get()));
break;
case Map::Hexagonal:
mRenderer.reset(new HexagonalRenderer(mMap.get()));
break;
case Map::Orthogonal:
default:
mRenderer.reset(new OrthogonalRenderer(mMap.get()));
break;
}
mScene->addItem(new MapItem(mMap.get(), mRenderer.get()));
return true;
}
void test_MapReader::loadMap()
{
MapReader reader;
Map *map = reader.readMap("../data/mapobject.tmx");
// TODO: Also test tilesets (internal and external), properties and tile
// layer data.
QVERIFY(map);
QCOMPARE(map->layerCount(), 2);
QCOMPARE(map->width(), 100);
QCOMPARE(map->height(), 80);
QCOMPARE(map->tileWidth(), 32);
QCOMPARE(map->tileHeight(), 32);
TileLayer *tileLayer = dynamic_cast<TileLayer*>(map->layerAt(0));
QVERIFY(tileLayer);
QCOMPARE(tileLayer->width(), 100);
QCOMPARE(tileLayer->height(), 80);
ObjectGroup *objectGroup = dynamic_cast<ObjectGroup*>(map->layerAt(1));
QVERIFY(objectGroup);
QCOMPARE(objectGroup->name(), QLatin1String("Objects"));
QCOMPARE(objectGroup->objects().count(), 1);
MapObject *mapObject = objectGroup->objects().at(0);
QCOMPARE(mapObject->name(), QLatin1String("Some object"));
QCOMPARE(mapObject->type(), QLatin1String("WARP"));
QCOMPARE(mapObject->x(), qreal(200));
QCOMPARE(mapObject->y(), qreal(200));
QCOMPARE(mapObject->width(), qreal(128));
QCOMPARE(mapObject->height(), qreal(64));
}
int TmxRasterizer::render(const QString &mapFileName,
const QString &imageFileName)
{
MapReader reader;
std::unique_ptr<Map> map { reader.readMap(mapFileName) };
if (!map) {
qWarning("Error while reading \"%s\":\n%s",
qUtf8Printable(mapFileName),
qUtf8Printable(reader.errorString()));
return 1;
}
std::unique_ptr<MapRenderer> renderer;
switch (map->orientation()) {
case Map::Isometric:
renderer.reset(new IsometricRenderer(map.get()));
break;
case Map::Staggered:
renderer.reset(new StaggeredRenderer(map.get()));
break;
case Map::Hexagonal:
renderer.reset(new HexagonalRenderer(map.get()));
break;
case Map::Orthogonal:
default:
renderer.reset(new OrthogonalRenderer(map.get()));
break;
}
QRect mapBoundingRect = renderer->mapBoundingRect();
QSize mapSize = mapBoundingRect.size();
QPoint mapOffset = mapBoundingRect.topLeft();
qreal xScale, yScale;
if (mSize > 0) {
xScale = (qreal) mSize / mapSize.width();
yScale = (qreal) mSize / mapSize.height();
xScale = yScale = qMin(1.0, qMin(xScale, yScale));
} else if (mTileSize > 0) {
xScale = (qreal) mTileSize / map->tileWidth();
yScale = (qreal) mTileSize / map->tileHeight();
} else {
xScale = yScale = mScale;
}
QMargins margins = map->computeLayerOffsetMargins();
mapSize.setWidth(mapSize.width() + margins.left() + margins.right());
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom());
mapSize.rwidth() *= xScale;
mapSize.rheight() *= yScale;
QImage image(mapSize, QImage::Format_ARGB32);
image.fill(Qt::transparent);
QPainter painter(&image);
painter.setRenderHint(QPainter::Antialiasing, mUseAntiAliasing);
painter.setRenderHint(QPainter::SmoothPixmapTransform, mSmoothImages);
painter.setTransform(QTransform::fromScale(xScale, yScale));
painter.translate(margins.left(), margins.top());
painter.translate(-mapOffset);
// Perform a similar rendering than found in exportasimagedialog.cpp
LayerIterator iterator(map.get());
while (const Layer *layer = iterator.next()) {
if (!shouldDrawLayer(layer))
continue;
const auto offset = layer->totalOffset();
painter.setOpacity(layer->effectiveOpacity());
painter.translate(offset);
const TileLayer *tileLayer = dynamic_cast<const TileLayer*>(layer);
const ImageLayer *imageLayer = dynamic_cast<const ImageLayer*>(layer);
if (tileLayer) {
renderer->drawTileLayer(&painter, tileLayer);
} else if (imageLayer) {
renderer->drawImageLayer(&painter, imageLayer);
}
painter.translate(-offset);
}
map.reset();
// Save image
QImageWriter imageWriter(imageFileName);
if (!imageWriter.canWrite())
imageWriter.setFormat("png");
if (!imageWriter.write(image)) {
qWarning("Error while writing \"%s\": %s",
qUtf8Printable(imageFileName),
qUtf8Printable(imageWriter.errorString()));
return 1;
}
return 0;
}