|
|
@@ -1,12 +1,28 @@
|
|
|
#include <string>
|
|
|
|
|
|
+#include <zlib.h>
|
|
|
+
|
|
|
+#include "Base64.h"
|
|
|
#include "TMXSceneEncoder.h"
|
|
|
|
|
|
using namespace gameplay;
|
|
|
using namespace tinyxml2;
|
|
|
using std::string;
|
|
|
|
|
|
-TMXSceneEncoder::TMXSceneEncoder()
|
|
|
+#ifdef GP_4_SPACE_TABS
|
|
|
+#define TAB_STRING(count) string((count) * 4, ' ')
|
|
|
+#else
|
|
|
+#define TAB_STRING(count) string((count), '\t')
|
|
|
+#endif
|
|
|
+
|
|
|
+#define BUFFER_SIZE 256
|
|
|
+
|
|
|
+#ifdef WIN32
|
|
|
+#define snprintf(s, n, fmt, ...) sprintf((s), (fmt), __VA_ARGS__)
|
|
|
+#endif
|
|
|
+
|
|
|
+TMXSceneEncoder::TMXSceneEncoder() :
|
|
|
+ _tabCount(0)
|
|
|
{
|
|
|
}
|
|
|
|
|
|
@@ -14,16 +30,613 @@ TMXSceneEncoder::~TMXSceneEncoder()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
-void TMXSceneEncoder::write(const string& filepath)
|
|
|
+void TMXSceneEncoder::write(const string& filepath, const EncoderArguments& arguments)
|
|
|
+{
|
|
|
+ XMLDocument xmlDoc;
|
|
|
+ XMLError err;
|
|
|
+ if ((err = xmlDoc.LoadFile(filepath.c_str())) != XML_NO_ERROR)
|
|
|
+ {
|
|
|
+ LOG(1, "Call to XMLDocument::LoadFile() failed.\n");
|
|
|
+ LOG(1, "Error returned: %d\n\n", err);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Parse the Tiled map
|
|
|
+ string outputFilePath = arguments.getOutputFilePath();
|
|
|
+ int pos = outputFilePath.find_last_of('/');
|
|
|
+ string outputDirectory = (pos == -1 ? outputFilePath : outputFilePath.substr(0, pos));
|
|
|
+
|
|
|
+ TMXMap map;
|
|
|
+ if (!parseTmx(xmlDoc, map, outputDirectory))
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ //XXX arguments.generateTextureGutter()
|
|
|
+
|
|
|
+ // Write the tile map
|
|
|
+ string fileName = arguments.getFileName();
|
|
|
+ pos = fileName.find_last_of('.');
|
|
|
+
|
|
|
+ writeScene(map, outputFilePath, (pos == -1 ? fileName : fileName.substr(0, pos)));
|
|
|
+}
|
|
|
+
|
|
|
+bool TMXSceneEncoder::parseTmx(const XMLDocument& xmlDoc, TMXMap& map, const std::string& outputDirectory) const
|
|
|
+{
|
|
|
+ auto xmlMap = xmlDoc.FirstChildElement("map");
|
|
|
+ if (!xmlMap)
|
|
|
+ {
|
|
|
+ LOG(1, "Missing root <map> element.\n");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Read in the map values //XXX should compact this so XML attribute parsing is a little nicer
|
|
|
+ unsigned int uiValue;
|
|
|
+ auto attValue = xmlMap->Attribute("width");
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ map.setWidth(uiValue);
|
|
|
+
|
|
|
+ attValue = xmlMap->Attribute("height");
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ map.setHeight(uiValue);
|
|
|
+
|
|
|
+ float fValue;
|
|
|
+ attValue = xmlMap->Attribute("tilewidth");
|
|
|
+ sscanf(attValue, "%f", &fValue);
|
|
|
+ map.setTileWidth(fValue);
|
|
|
+
|
|
|
+ attValue = xmlMap->Attribute("tileheight");
|
|
|
+ sscanf(attValue, "%f", &fValue);
|
|
|
+ map.setTileHeight(fValue);
|
|
|
+
|
|
|
+ // Now we load all tilesets
|
|
|
+ auto xmlTileSet = xmlMap->FirstChildElement("tileset");
|
|
|
+ while (xmlTileSet)
|
|
|
+ {
|
|
|
+ TMXTileSet tileSet;
|
|
|
+
|
|
|
+ attValue = xmlTileSet->Attribute("firstgid");
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ tileSet.setFirstGid(uiValue);
|
|
|
+
|
|
|
+ XMLDocument sourceXmlDoc;
|
|
|
+ const XMLElement* xmlTileSetToLoad;
|
|
|
+ attValue = xmlTileSet->Attribute("source");
|
|
|
+ if (attValue)
|
|
|
+ {
|
|
|
+ string tsxLocation = outputDirectory + "/" + attValue;
|
|
|
+ tsxLocation = EncoderArguments::getRealPath(tsxLocation);
|
|
|
+
|
|
|
+ XMLError err;
|
|
|
+ if ((err = sourceXmlDoc.LoadFile(tsxLocation.c_str())) != XML_NO_ERROR)
|
|
|
+ {
|
|
|
+ LOG(1, "Could not load tileset's source TSX.\n");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ xmlTileSetToLoad = sourceXmlDoc.RootElement();
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ xmlTileSetToLoad = xmlTileSet;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Maximum tile size
|
|
|
+ attValue = xmlTileSetToLoad->Attribute("tilewidth");
|
|
|
+ if (attValue)
|
|
|
+ {
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ tileSet.setMaxTileWidth(uiValue);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ tileSet.setMaxTileWidth(map.getTileWidth());
|
|
|
+ }
|
|
|
+ attValue = xmlTileSetToLoad->Attribute("tileheight");
|
|
|
+ if (attValue)
|
|
|
+ {
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ tileSet.setMaxTileHeight(uiValue);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ tileSet.setMaxTileHeight(map.getTileHeight());
|
|
|
+ }
|
|
|
+
|
|
|
+ // Spacing and margin
|
|
|
+ attValue = xmlTileSetToLoad->Attribute("spacing");
|
|
|
+ if (attValue)
|
|
|
+ {
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ tileSet.setSpacing(uiValue);
|
|
|
+ }
|
|
|
+ attValue = xmlTileSetToLoad->Attribute("margin");
|
|
|
+ if (attValue)
|
|
|
+ {
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ tileSet.setMargin(uiValue);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Tile offset
|
|
|
+ auto xmlTileOffset = xmlTileSetToLoad->FirstChildElement("tileoffset");
|
|
|
+ if (xmlTileOffset)
|
|
|
+ {
|
|
|
+ Vector2 offset;
|
|
|
+ int iValue;
|
|
|
+
|
|
|
+ attValue = xmlTileOffset->Attribute("x");
|
|
|
+ sscanf(attValue, "%d", &iValue);
|
|
|
+ offset.x = iValue;
|
|
|
+ attValue = xmlTileOffset->Attribute("y");
|
|
|
+ sscanf(attValue, "%d", &iValue);
|
|
|
+ offset.y = iValue;
|
|
|
+
|
|
|
+ tileSet.setOffset(offset);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Load image source. Don't worry about <data>, trans, or height
|
|
|
+ auto xmlTileSetImage = xmlTileSetToLoad->FirstChildElement("image");
|
|
|
+ tileSet.setImagePath(xmlTileSetImage->Attribute("source"));
|
|
|
+
|
|
|
+ // We only care about image width...
|
|
|
+ attValue = xmlTileSetImage->Attribute("width");
|
|
|
+ if (attValue)
|
|
|
+ {
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ tileSet.setImageWidth(uiValue);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // Load the image itself to get the width
|
|
|
+ string imageLocation = outputDirectory + "/" + tileSet.getImagePath();
|
|
|
+ imageLocation = EncoderArguments::getRealPath(imageLocation);
|
|
|
+
|
|
|
+ int pos = imageLocation.find_last_of('.');
|
|
|
+ if (imageLocation.substr(pos).compare(".png") != 0)
|
|
|
+ {
|
|
|
+ LOG(1, "TileSet image must be a PNG. %s\n", imageLocation.c_str());
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ Image* img = Image::create(imageLocation.c_str());
|
|
|
+ if (!img)
|
|
|
+ {
|
|
|
+ LOG(1, "Could not load TileSet image. %s\n", imageLocation.c_str());
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ tileSet.setImageWidth(img->getWidth());
|
|
|
+ SAFE_DELETE(img);
|
|
|
+ }
|
|
|
+
|
|
|
+ //TODO: tiles (specifically, tile animations)
|
|
|
+ //<tile id="relId"><animation><frame tileid="relId" duration="numInMS"></...></...></...>
|
|
|
+
|
|
|
+ // Save the tileset
|
|
|
+ map.addTileSet(tileSet);
|
|
|
+
|
|
|
+ xmlTileSet = xmlTileSet->NextSiblingElement("tileset");
|
|
|
+ }
|
|
|
+
|
|
|
+ // Finally we load the layers
|
|
|
+ auto xmlLayer = xmlMap->FirstChildElement("layer");
|
|
|
+ while (xmlLayer)
|
|
|
+ {
|
|
|
+ TMXLayer layer;
|
|
|
+
|
|
|
+ //XXX what if name doesn't exist?
|
|
|
+ layer.setName(xmlLayer->Attribute("name"));
|
|
|
+
|
|
|
+ // Load properties
|
|
|
+ attValue = xmlLayer->Attribute("width");
|
|
|
+ if (attValue)
|
|
|
+ {
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ layer.setWidth(uiValue);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ layer.setWidth(map.getWidth());
|
|
|
+ }
|
|
|
+
|
|
|
+ attValue = xmlLayer->Attribute("height");
|
|
|
+ if (attValue)
|
|
|
+ {
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ layer.setHeight(uiValue);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ layer.setHeight(map.getHeight());
|
|
|
+ }
|
|
|
+
|
|
|
+ attValue = xmlLayer->Attribute("opacity");
|
|
|
+ if (attValue)
|
|
|
+ {
|
|
|
+ sscanf(attValue, "%f", &fValue);
|
|
|
+ layer.setOpacity(fValue);
|
|
|
+ }
|
|
|
+
|
|
|
+ attValue = xmlLayer->Attribute("visible");
|
|
|
+ if (attValue)
|
|
|
+ {
|
|
|
+ sscanf(attValue, "%u", &uiValue);
|
|
|
+ layer.setVisible(uiValue == 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Load tiles
|
|
|
+ layer.setupTiles();
|
|
|
+ auto data = loadDataElement(xmlLayer->FirstChildElement("data"));
|
|
|
+ auto data_size = data.size();
|
|
|
+ for (int i = 0; i < data_size; i++)
|
|
|
+ {
|
|
|
+ //XXX this might depend on map's renderorder
|
|
|
+ auto x = i % layer.getWidth();
|
|
|
+ auto y = i / layer.getWidth();
|
|
|
+ layer.setTile(x, y, data[i]);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Save layer
|
|
|
+ map.addLayer(layer);
|
|
|
+
|
|
|
+ xmlLayer = xmlLayer->NextSiblingElement("layer");
|
|
|
+ }
|
|
|
+
|
|
|
+ //TODO: imagelayer (a kind of individual sprite)
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+//XXX could probably seperate the writing process to a seperate class (PropertyWriter...)
|
|
|
+#define WRITE_PROPERTY_BLOCK_START(str) writeLine(file, (str)); \
|
|
|
+ writeLine(file, "{"); \
|
|
|
+ _tabCount++
|
|
|
+#define WRITE_PROPERTY_BLOCK_END() _tabCount--; \
|
|
|
+ writeLine(file, "}")
|
|
|
+#define WRITE_PROPERTY_BLOCK_VALUE(name, value) writeLine(file, string(name) + " = " + (value))
|
|
|
+#define WRITE_PROPERTY_DIRECT(value) writeLine(file, (value))
|
|
|
+#define WRITE_PROPERTY_NEWLINE() file << std::endl
|
|
|
+
|
|
|
+void TMXSceneEncoder::writeScene(const TMXMap& map, const string& outputFilepath, const string& sceneName)
|
|
|
+{
|
|
|
+ // Prepare for writing the scene
|
|
|
+ std::ofstream file(outputFilepath.c_str(), std::ofstream::out | std::ofstream::trunc);
|
|
|
+
|
|
|
+ auto tilesetCount = map.getLayerCount();
|
|
|
+ bool singleLayer = tilesetCount <= 1;
|
|
|
+
|
|
|
+ //XXX should really build an ordered list, and draw based on that (for z-depth)
|
|
|
+
|
|
|
+ // Write initial scene
|
|
|
+ WRITE_PROPERTY_BLOCK_START("scene " + sceneName);
|
|
|
+ if (!singleLayer)
|
|
|
+ {
|
|
|
+ WRITE_PROPERTY_BLOCK_START("node all_tilesets"); //XXX what if there are sprites between tilesets?
|
|
|
+ }
|
|
|
+
|
|
|
+ // Write all tilesets
|
|
|
+ for (auto i = 0u; i < tilesetCount; i++)
|
|
|
+ {
|
|
|
+ writeTileset(map, i, file);
|
|
|
+ WRITE_PROPERTY_NEWLINE();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!singleLayer)
|
|
|
+ {
|
|
|
+ WRITE_PROPERTY_BLOCK_END(); // node tilesets
|
|
|
+ }
|
|
|
+
|
|
|
+ //TODO: other sprites
|
|
|
+
|
|
|
+ WRITE_PROPERTY_BLOCK_END(); // scene
|
|
|
+
|
|
|
+ // Cleanup
|
|
|
+ file.flush();
|
|
|
+ file.close();
|
|
|
+}
|
|
|
+
|
|
|
+// This is actually a misnomer. What is a Layer in Tiled/TMX is a TileSet for GamePlay3d. TileSet in Tiled/TMX is something different.
|
|
|
+void TMXSceneEncoder::writeTileset(const TMXMap& map, unsigned int tileSetIndex, std::ofstream& file)
|
|
|
+{
|
|
|
+ auto tileset = map.getLayer(tileSetIndex);
|
|
|
+ if (!tileset.hasTiles())
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ auto tilesets = tileset.getTilesetsUsed(map);
|
|
|
+ if (tilesets.size() == 0)
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ char buffer[BUFFER_SIZE];
|
|
|
+ WRITE_PROPERTY_BLOCK_START("node " + tileset.getName());
|
|
|
+ if (tilesets.size() > 1)
|
|
|
+ {
|
|
|
+ auto i = 0u;
|
|
|
+ for (auto it = tilesets.begin(); it != tilesets.end(); it++, i++)
|
|
|
+ {
|
|
|
+ snprintf(buffer, BUFFER_SIZE, "node tileset_%d", i);
|
|
|
+ WRITE_PROPERTY_BLOCK_START(buffer);
|
|
|
+
|
|
|
+ auto tmxTileset = map.getTileSet(*it);
|
|
|
+ writeSoloTileset(map, tmxTileset, tileset, file, *it);
|
|
|
+
|
|
|
+ auto tileOffset = tmxTileset.getOffset();
|
|
|
+ if (!(tileOffset == Vector2::zero()))
|
|
|
+ {
|
|
|
+ // Tile offset moves the tiles, not the origin of each tile
|
|
|
+ snprintf(buffer, BUFFER_SIZE, "translate = %d, %d, 0", static_cast<int>(tileOffset.x), static_cast<int>(tileOffset.y));
|
|
|
+ WRITE_PROPERTY_NEWLINE();
|
|
|
+ WRITE_PROPERTY_DIRECT(buffer);
|
|
|
+ }
|
|
|
+
|
|
|
+ WRITE_PROPERTY_BLOCK_END();
|
|
|
+ if ((i + 1) != tilesets.size())
|
|
|
+ {
|
|
|
+ WRITE_PROPERTY_NEWLINE();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ auto tmxTileset = map.getTileSet(*(tilesets.begin()));
|
|
|
+ writeSoloTileset(map, tmxTileset, tileset, file);
|
|
|
+
|
|
|
+ auto tileOffset = tmxTileset.getOffset();
|
|
|
+ if (!(tileOffset == Vector2::zero()))
|
|
|
+ {
|
|
|
+ // Tile offset moves the tiles, not the origin of each tile
|
|
|
+ snprintf(buffer, BUFFER_SIZE, "translate = %d, %d, 0", static_cast<int>(tileOffset.x), static_cast<int>(tileOffset.y));
|
|
|
+ WRITE_PROPERTY_NEWLINE();
|
|
|
+ WRITE_PROPERTY_DIRECT(buffer);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!tileset.getVisible())
|
|
|
+ {
|
|
|
+ // Default is true, so only write it false
|
|
|
+ WRITE_PROPERTY_NEWLINE();
|
|
|
+ WRITE_PROPERTY_DIRECT("enabled = false");
|
|
|
+ }
|
|
|
+ WRITE_PROPERTY_BLOCK_END();
|
|
|
+}
|
|
|
+
|
|
|
+void TMXSceneEncoder::writeSoloTileset(const TMXMap& map, const gameplay::TMXTileSet& tmxTileset, const TMXLayer& tileset, std::ofstream& file, unsigned int resultOnlyForTileset)
|
|
|
+{
|
|
|
+ WRITE_PROPERTY_BLOCK_START("tileset");
|
|
|
+
|
|
|
+ // Write tile path
|
|
|
+ WRITE_PROPERTY_BLOCK_VALUE("path", tmxTileset.getImagePath());
|
|
|
+ WRITE_PROPERTY_NEWLINE();
|
|
|
+
|
|
|
+ // Write tile size
|
|
|
+ //XXX if tile sizes are incorrect, make sure to update TMXLayer::getTileStart too
|
|
|
+ char buffer[BUFFER_SIZE];
|
|
|
+ snprintf(buffer, BUFFER_SIZE, "tileWidth = %u", tmxTileset.getMaxTileWidth());
|
|
|
+ WRITE_PROPERTY_DIRECT(buffer);
|
|
|
+ snprintf(buffer, BUFFER_SIZE, "tileHeight = %u", tmxTileset.getMaxTileHeight());
|
|
|
+ WRITE_PROPERTY_DIRECT(buffer);
|
|
|
+
|
|
|
+ // Write tileset size
|
|
|
+ snprintf(buffer, BUFFER_SIZE, "columns = %u", tileset.getWidth());
|
|
|
+ WRITE_PROPERTY_DIRECT(buffer);
|
|
|
+ snprintf(buffer, BUFFER_SIZE, "rows = %u", tileset.getHeight());
|
|
|
+ WRITE_PROPERTY_DIRECT(buffer);
|
|
|
+ WRITE_PROPERTY_NEWLINE();
|
|
|
+
|
|
|
+ // Write opacity
|
|
|
+ if (tileset.getOpacity() < 1.0f)
|
|
|
+ {
|
|
|
+ snprintf(buffer, BUFFER_SIZE, "opacity = %f", tileset.getOpacity());
|
|
|
+ WRITE_PROPERTY_DIRECT(buffer);
|
|
|
+ WRITE_PROPERTY_NEWLINE();
|
|
|
+ }
|
|
|
+
|
|
|
+ // Write tiles
|
|
|
+ auto tileset_height = tileset.getHeight();
|
|
|
+ auto tileset_width = tileset.getWidth();
|
|
|
+ for (auto y = 0u; y < tileset_height; y++)
|
|
|
+ {
|
|
|
+ bool tilesWritten = false;
|
|
|
+ for (auto x = 0u; x < tileset_width; x++)
|
|
|
+ {
|
|
|
+ Vector2 startPos = tileset.getTileStart(x, y, map, resultOnlyForTileset);
|
|
|
+ if (startPos.x < 0 || startPos.y < 0)
|
|
|
+ {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ tilesWritten = true;
|
|
|
+ WRITE_PROPERTY_BLOCK_START("tile");
|
|
|
+ snprintf(buffer, BUFFER_SIZE, "cell = %u, %u", x, y);
|
|
|
+ WRITE_PROPERTY_DIRECT(buffer);
|
|
|
+ snprintf(buffer, BUFFER_SIZE, "source = %u, %u", static_cast<unsigned int>(startPos.x), static_cast<unsigned int>(startPos.y));
|
|
|
+ WRITE_PROPERTY_DIRECT(buffer);
|
|
|
+ WRITE_PROPERTY_BLOCK_END();
|
|
|
+ }
|
|
|
+ if (tilesWritten && ((y + 1) != tileset_height))
|
|
|
+ {
|
|
|
+ WRITE_PROPERTY_NEWLINE();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ WRITE_PROPERTY_BLOCK_END();
|
|
|
+}
|
|
|
+
|
|
|
+#undef WRITE_PROPERTY_NEWLINE
|
|
|
+#undef WRITE_PROPERTY_DIRECT
|
|
|
+#undef WRITE_PROPERTY_BLOCK_VALUE
|
|
|
+#undef WRITE_PROPERTY_BLOCK_END
|
|
|
+#undef WRITE_PROPERTY_BLOCK_START
|
|
|
+
|
|
|
+void TMXSceneEncoder::writeLine(std::ofstream& file, const string& line) const
|
|
|
+{
|
|
|
+ file << TAB_STRING(_tabCount) << line << std::endl;
|
|
|
+}
|
|
|
+
|
|
|
+bool isBase64(char c)
|
|
|
+{
|
|
|
+ return (c >= 'a' && c <= 'z') ||
|
|
|
+ (c >= 'A' && c <= 'Z') ||
|
|
|
+ (c >= '0' && c <= '9') ||
|
|
|
+ (c == '=');
|
|
|
+}
|
|
|
+
|
|
|
+std::vector<unsigned int> TMXSceneEncoder::loadDataElement(const XMLElement* data)
|
|
|
{
|
|
|
- XMLDocument xmlDoc;
|
|
|
- XMLError err;
|
|
|
- if ((err = xmlDoc.LoadFile(filepath.c_str())) != XML_NO_ERROR)
|
|
|
- {
|
|
|
- LOG(1, "Call to XMLDocument::LoadFile() failed.\n");
|
|
|
- LOG(1, "Error returned: %d\n\n", err);
|
|
|
- exit(-1);
|
|
|
- }
|
|
|
+ if (!data)
|
|
|
+ {
|
|
|
+ return std::vector<unsigned int>();
|
|
|
+ }
|
|
|
+
|
|
|
+ const char* encoding = data->Attribute("encoding");
|
|
|
+ const char* compression = data->Attribute("compression");
|
|
|
+
|
|
|
+ const char* attValue = "0";
|
|
|
+ unsigned int tileGid;
|
|
|
+ std::vector<unsigned int> tileData;
|
|
|
+
|
|
|
+ if (!compression && !encoding)
|
|
|
+ {
|
|
|
+ auto xmlTile = data->FirstChildElement("tile");
|
|
|
+ while (xmlTile)
|
|
|
+ {
|
|
|
+ attValue = xmlTile->Attribute("gid");
|
|
|
+ sscanf(attValue, "%u", &tileGid);
|
|
|
+ tileData.push_back(tileGid);
|
|
|
+
|
|
|
+ xmlTile = xmlTile->NextSiblingElement("tile");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (strcmp(encoding, "csv") == 0)
|
|
|
+ {
|
|
|
+ if (compression)
|
|
|
+ {
|
|
|
+ LOG(1, "Compression is not supported with CSV encoding.\n");
|
|
|
+ exit(-1);
|
|
|
+ }
|
|
|
+
|
|
|
+ auto rawCsvData = data->GetText();
|
|
|
+ int start = 0;
|
|
|
+ char* endptr;
|
|
|
+ // Skip everything before values
|
|
|
+ while (rawCsvData[start] == ' ' || rawCsvData[start] == '\n' || rawCsvData[start] == '\r' || rawCsvData[start] == '\t')
|
|
|
+ {
|
|
|
+ start++;
|
|
|
+ }
|
|
|
+ // Iterate through values. Skipping to next value when done
|
|
|
+ while (rawCsvData[start])
|
|
|
+ {
|
|
|
+ tileData.push_back(strtoul(rawCsvData + start, &endptr, 10));
|
|
|
+ start = endptr - rawCsvData;
|
|
|
+ while (rawCsvData[start] == ' ' || rawCsvData[start] == ',' || rawCsvData[start] == '\n' || rawCsvData[start] == '\r' || rawCsvData[start] == '\t')
|
|
|
+ {
|
|
|
+ start++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if (strcmp(encoding, "base64") == 0)
|
|
|
+ {
|
|
|
+ string base64Data = data->GetText();
|
|
|
+ if (base64Data.size() > 0 && (!isBase64(base64Data[0]) || !isBase64(base64Data[base64Data.size() - 1])))
|
|
|
+ {
|
|
|
+ int start = 0;
|
|
|
+ auto end = base64Data.size() - 1;
|
|
|
+ while (!isBase64(base64Data[start]))
|
|
|
+ {
|
|
|
+ start++;
|
|
|
+ }
|
|
|
+ while (!isBase64(base64Data[end]))
|
|
|
+ {
|
|
|
+ end--;
|
|
|
+ }
|
|
|
+ base64Data = base64Data.substr(start, end - start + 1);
|
|
|
+ }
|
|
|
+ auto byteData = base64_decode(base64Data);
|
|
|
+
|
|
|
+ if (compression)
|
|
|
+ {
|
|
|
+ int err;
|
|
|
+ const unsigned int buffer_size = 4096;
|
|
|
+ char buffer[buffer_size];
|
|
|
+ string decomData;
|
|
|
+
|
|
|
+ if (strcmp(compression, "zlib") == 0 || strcmp(compression, "gzip") == 0)
|
|
|
+ {
|
|
|
+ z_stream d_stream;
|
|
|
+ d_stream.zalloc = Z_NULL;
|
|
|
+ d_stream.zfree = Z_NULL;
|
|
|
+ d_stream.opaque = Z_NULL;
|
|
|
+ d_stream.next_in = (Bytef*)byteData.c_str();
|
|
|
+ d_stream.avail_in = byteData.size();
|
|
|
+
|
|
|
+ if (strcmp(compression, "zlib") == 0)
|
|
|
+ {
|
|
|
+ // zlib
|
|
|
+ if ((err = inflateInit(&d_stream)) != Z_OK)
|
|
|
+ {
|
|
|
+ LOG(1, "ZLIB inflateInit failed. Error: %d.\n", err);
|
|
|
+ exit(-1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // gzip
|
|
|
+ if ((err = inflateInit2(&d_stream, 16+MAX_WBITS)) != Z_OK)
|
|
|
+ {
|
|
|
+ LOG(1, "ZLIB inflateInit2 failed. Error: %d.\n", err);
|
|
|
+ exit(-1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ do
|
|
|
+ {
|
|
|
+ d_stream.next_out = (Bytef*)buffer;
|
|
|
+ d_stream.avail_out = buffer_size;
|
|
|
+ err = inflate(&d_stream, Z_NO_FLUSH);
|
|
|
+ switch (err)
|
|
|
+ {
|
|
|
+ case Z_NEED_DICT:
|
|
|
+ case Z_DATA_ERROR:
|
|
|
+ case Z_MEM_ERROR:
|
|
|
+ inflateEnd(&d_stream);
|
|
|
+ LOG(1, "ZLIB inflate failed. Error: %d.\n", err);
|
|
|
+ exit(-1);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ string decomBlock(buffer, buffer_size - d_stream.avail_out);
|
|
|
+ decomData += decomBlock;
|
|
|
+ } while (err != Z_STREAM_END);
|
|
|
+
|
|
|
+ inflateEnd(&d_stream);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ LOG(1, "Unknown compression: %s.\n", compression);
|
|
|
+ exit(-1);
|
|
|
+ }
|
|
|
+
|
|
|
+ byteData = decomData;
|
|
|
+ }
|
|
|
+
|
|
|
+ auto byteDataSize = byteData.size();
|
|
|
+ for (unsigned int i = 0; i < byteDataSize; i += 4)
|
|
|
+ {
|
|
|
+ unsigned int gid = static_cast<unsigned char>(byteData[i + 0]) |
|
|
|
+ (static_cast<unsigned char>(byteData[i + 1]) << 8u) |
|
|
|
+ (static_cast<unsigned char>(byteData[i + 2]) << 16u) |
|
|
|
+ (static_cast<unsigned char>(byteData[i + 3]) << 24u);
|
|
|
+ tileData.push_back(gid);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ LOG(1, "Unknown encoding: %s.\n", encoding);
|
|
|
+ exit(-1);
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- //TODO
|
|
|
+ return tileData;
|
|
|
}
|
Rcmaniac25