1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;
using Microsoft.Xna.Framework.Content.Pipeline;
using MonoGame.Extended.Tiled.Serialization;
namespace MonoGame.Extended.Content.Pipeline.Tiled
{
[ContentImporter(".tmx", DefaultProcessor = "TiledMapProcessor", DisplayName = "Tiled Map Importer - MonoGame.Extended")]
public class TiledMapImporter : ContentImporter<TiledMapContentItem>
{
public override TiledMapContentItem Import(string filePath, ContentImporterContext context)
{
try
{
if (filePath == null)
throw new ArgumentNullException(nameof(filePath));
ContentLogger.Logger = context.Logger;
ContentLogger.Log($"Importing '{filePath}'");
var map = DeserializeTiledMapContent(filePath, context);
if (map.Width > ushort.MaxValue || map.Height > ushort.MaxValue)
throw new InvalidContentException($"The map '{filePath} is much too large. The maximum supported width and height for a Tiled map is {ushort.MaxValue}.");
ContentLogger.Log($"Imported '{filePath}'");
return new TiledMapContentItem(map);
}
catch (Exception e)
{
context.Logger.LogImportantMessage(e.StackTrace);
throw;
}
}
private static TiledMapContent DeserializeTiledMapContent(string mapFilePath, ContentImporterContext context)
{
using (var reader = new StreamReader(mapFilePath))
{
var mapSerializer = new XmlSerializer(typeof(TiledMapContent));
var map = (TiledMapContent)mapSerializer.Deserialize(reader);
map.FilePath = mapFilePath;
for (var i = 0; i < map.Tilesets.Count; i++)
{
var tileset = map.Tilesets[i];
string getTilesetSource(string source)
=> Path.GetFullPath(Path.Combine(Path.GetDirectoryName(mapFilePath), source));
if (!string.IsNullOrWhiteSpace(tileset.Source))
{
tileset.Source = getTilesetSource(tileset.Source);
ContentLogger.Log($"Adding dependency for {tileset.Source}");
// We depend on the tileset. If the tileset changes, the map also needs to rebuild.
context.AddDependency(tileset.Source);
}
else
{
tileset.Image.Source = getTilesetSource(tileset.Image.Source);
ContentLogger.Log($"Adding dependency for {tileset.Image.Source}");
context.AddDependency(tileset.Image.Source);
}
}
ImportLayers(context, map.Layers, Path.GetDirectoryName(mapFilePath));
map.Name = mapFilePath;
return map;
}
}
private static void ImportLayers(ContentImporterContext context, List<TiledMapLayerContent> layers, string path)
{
for (var i = 0; i < layers.Count; i++)
{
if (layers[i] is TiledMapImageLayerContent imageLayer)
{
imageLayer.Image.Source = Path.Combine(path, imageLayer.Image.Source);
ContentLogger.Log($"Adding dependency for '{imageLayer.Image.Source}'");
// Tell the pipeline that we depend on this image and need to rebuild the map if the image changes.
// (Maybe the image is a different size)
context.AddDependency(imageLayer.Image.Source);
}
if (layers[i] is TiledMapObjectLayerContent objectLayer)
foreach (var obj in objectLayer.Objects)
if (!String.IsNullOrWhiteSpace(obj.TemplateSource))
{
obj.TemplateSource = Path.Combine(path, obj.TemplateSource);
ContentLogger.Log($"Adding dependency for '{obj.TemplateSource}'");
// Tell the pipeline that we depend on this template and need to rebuild the map if the template changes.
// (Templates are loaded into objects on process, so all objects which depend on the template file
// need the change to the template)
context.AddDependency(obj.TemplateSource);
}
if (layers[i] is TiledMapGroupLayerContent groupLayer)
// Yay recursion!
ImportLayers(context, groupLayer.Layers, path);
}
}
}
}
|
