static ImportedTile[] ImportEmbeddedTileset(TMX.TilesetReference embeddedTileset, string tilesetDir, string baseFolder, int cellWidth, int cellHeight, int pixelsPerUnit, out TSX.Tileset tilesetOut)
{
TSX.Tileset tileset = new TSX.Tileset(embeddedTileset);
tilesetOut = tileset;
if (!ImportUtils.CreateAssetFolderIfMissing(tilesetDir, true))
{
return(null);
}
Debug.Log("Loading embedded tileset = " + tileset.name);
return(ImportTileset(tileset, tilesetDir, baseFolder, cellWidth, cellHeight, pixelsPerUnit));
}
static void CreateSingleImageTilesetPaths(TSX.Tileset tileset, string pathWithoutFile, string tilesetSpriteTargetDir, string tilesetTileTargetDir, out string imageSourcePath, out string imageTargetPath, out string[] tileTargetPaths)
{
imageSourcePath = tileset.image.source;
imageSourcePath = Path.Combine(pathWithoutFile, imageSourcePath);
string imageName = Path.GetFileName(imageSourcePath);
imageTargetPath = Path.Combine(tilesetSpriteTargetDir, imageName);
tileTargetPaths = new string[tileset.tilecount];
for (int i = 0; i < tileset.tilecount; i++)
{
string tileName = Path.GetFileNameWithoutExtension(imageSourcePath) + "_" + i + ".asset";
tileTargetPaths[i] = Path.Combine(tilesetTileTargetDir, tileName);
}
}
static ImportedTile[] ImportTSXFile(string path, string tilesetDir, int cellWidth, int cellHeight, int pixelsPerUnit, out TSX.Tileset tilesetOut)
{
tilesetOut = null;
if (!ImportUtils.CreateAssetFolderIfMissing(tilesetDir, true))
{
return(null);
}
Debug.Log("Loading TSX file from " + path + " into " + tilesetDir);
TSX.Tileset tileset = ImportUtils.ReadXMLIntoObject <TSX.Tileset>(path);
if (tileset == null)
{
return(null);
}
tilesetOut = tileset;
Debug.Log("Loading tileset = " + tileset.name);
return(ImportTileset(tileset, tilesetDir, Path.GetDirectoryName(path), cellWidth, cellHeight, pixelsPerUnit));
}
static ImportedTile[] ImportTileset(TSX.Tileset tileset, string tilesetDir, string sourceTilesetDirectory, int cellWidth, int cellHeight, int pixelsPerUnit)
{
string tilesetSpriteTargetDir = tilesetDir + Path.DirectorySeparatorChar + tileset.name;
if (!ImportUtils.CreateAssetFolderIfMissing(tilesetSpriteTargetDir, false))
{
return(null);
}
string tilesetTileTargetDir = tilesetDir + Path.DirectorySeparatorChar + tileset.name + Path.DirectorySeparatorChar + "TileAssets";
if (!ImportUtils.CreateAssetFolderIfMissing(tilesetTileTargetDir, false))
{
return(null);
}
TSX.Tile[] tiles = tileset.tiles;
string[] imageTargetPaths = null;
Sprite[] tileSprites = null;
string[] tileTargetPaths = null;
bool singleImageTileset = tileset.IsSingleImageTileset();
if (singleImageTileset)
{
if (tileset.image != null)
{
string imageSourcePath;
string imageTargetPath;
CreateSingleImageTilesetPaths(tileset, sourceTilesetDirectory, tilesetSpriteTargetDir, tilesetTileTargetDir, out imageSourcePath, out imageTargetPath, out tileTargetPaths);
CopyImages(new string[] { imageSourcePath }, new string[] { imageTargetPath });
string subSpriteNameBase = Path.GetFileNameWithoutExtension(imageSourcePath);
if (!CreateTilemapSprite(imageTargetPath, cellWidth, cellHeight, pixelsPerUnit, tileset /*tileset.image.width, tileset.image.height, tileset.tilewidth, tileset.tileheight, tileset.tilecount*/, subSpriteNameBase, out tileSprites))
{
return(null);
}
}
else
{
Debug.LogError("Tileset " + tileset.name + " is empty!");
}
}
else
{
string[] imageSourcePaths = new string[tiles.Length];
imageTargetPaths = new string[tiles.Length];
tileTargetPaths = new string[tiles.Length];
CreateTilePaths(tiles, sourceTilesetDirectory, tilesetSpriteTargetDir, tilesetTileTargetDir, imageSourcePaths, imageTargetPaths, tileTargetPaths);
CopyImages(imageSourcePaths, imageTargetPaths);
tileSprites = new Sprite[tiles.Length];
CreateSpriteAssets(tiles, tileset.name, pixelsPerUnit, cellWidth, cellHeight, imageTargetPaths, tileSprites);
}
if (tileSprites == null)
{
Debug.LogError("Tile sprites ended up null when importing tileset: " + tileset.name);
return(null);
}
if (tileSprites.Length == 0)
{
Debug.LogError("0 tile sprites found from texture assets for tileset: " + tileset.name);
return(null);
}
ImportedTile[] tileAssets;
bool success = CreateTileAssets(tiles, singleImageTileset, tileset.name, pixelsPerUnit, tileSprites, tileTargetPaths, out tileAssets);
EditorUtility.ClearProgressBar();
if (!success)
{
return(null);
}
CreatePalette(tileset.name, tilesetTileTargetDir, tileAssets, singleImageTileset, tileset.tilewidth, tileset.tileheight, tileset.columns, cellWidth, cellHeight);
return(tileAssets);
}
static bool CreateTilemapSprite(string targetPath, int cellWidth, int cellHeight, int pixelsPerUnit, TSX.Tileset tileset /*int width, int height, int tileWidth, int tileHeight, int tileCount*/, string subSpriteNameBase, out Sprite[] tileSprites)
{
TextureImporter ti = AssetImporter.GetAtPath(targetPath) as TextureImporter;
TextureImporterSettings textureSettings = new TextureImporterSettings();
ti.ReadTextureSettings(textureSettings);
SpriteMeshType meshType = SpriteMeshType.FullRect;
SpriteAlignment alignment = SpriteAlignment.Custom;
Vector2 pivot = GetPivot(tileset.image.width, tileset.image.height, cellWidth, cellHeight);
FilterMode filterMode = FilterMode.Point;
SpriteImportMode importMode = SpriteImportMode.Multiple;
if (textureSettings.spritePixelsPerUnit != pixelsPerUnit ||
textureSettings.spriteMeshType != meshType ||
textureSettings.spriteAlignment != (int)alignment ||
textureSettings.spritePivot != pivot ||
textureSettings.filterMode != filterMode ||
textureSettings.spriteMode != (int)importMode)
{
textureSettings.spritePixelsPerUnit = pixelsPerUnit;
textureSettings.spriteMeshType = meshType;
textureSettings.spriteAlignment = (int)alignment;
textureSettings.spritePivot = pivot;
textureSettings.filterMode = filterMode;
textureSettings.spriteMode = (int)importMode;
ti.SetTextureSettings(textureSettings);
List <SpriteMetaData> newData = new List <SpriteMetaData>(tileset.tilecount);
int i = 0;
for (int y = tileset.image.height - tileset.margin; y > 0; y -= (tileset.tileheight + tileset.spacing))
{
for (int x = tileset.margin; x < tileset.image.width; x += (tileset.tilewidth + tileset.spacing))
{
SpriteMetaData data = new SpriteMetaData();
data.name = subSpriteNameBase + "_" + i;
data.alignment = (int)alignment;
data.pivot = GetPivot(tileset.tilewidth, tileset.tileheight, cellWidth, cellHeight);
data.rect = new Rect(x, y - tileset.tileheight, tileset.tilewidth, tileset.tileheight);
newData.Add(data);
i++;
if (i >= tileset.tilecount)
{
break;
}
}
if (i >= tileset.tilecount)
{
break;
}
}
ti.spritesheet = newData.ToArray();
EditorUtility.SetDirty(ti);
ti.SaveAndReimport();
}
Sprite[] subSprites = AssetDatabase.LoadAllAssetsAtPath(targetPath).OfType <Sprite>().ToArray();
// For some reason Unity thinks it's smart to return the sub-sprites in random order...
// ...and provide no API for retrieving sub-sprites by index >_<
// so we have to manually sort them by the ids in their names
Array.Sort <Sprite>(subSprites, new SpriteComparer());
tileSprites = subSprites;
return(true);
}
public ImportedTileset(ImportedTile[] tilesIn, int firstGIDIn, TSX.Tileset tilesetIn)
{
tiles = tilesIn;
firstGID = firstGIDIn;
tileset = tilesetIn;
}
