public override TmxMap Import(string filename, ContentImporterContext context)
{
if (filename == null)
{
throw new ArgumentNullException(nameof(filename));
}
using (var reader = new StreamReader(filename))
{
context.Logger.LogMessage("Deserializing filename: {0}", filename);
var serializer = new XmlSerializer(typeof(TmxMap));
var map = (TmxMap)serializer.Deserialize(reader);
var xmlSerializer = new XmlSerializer(typeof(TmxTileset));
foreach (var l in map.Layers)
{
context.Logger.LogMessage("Deserialized Layer: {0}", l);
}
foreach (var o in map.ObjectGroups)
{
context.Logger.LogMessage("Deserialized ObjectGroup: {0}, object count: {1}", o.Name, o.Objects.Count);
}
context.Logger.LogMessage("");
for (var i = 0; i < map.Tilesets.Count; i++)
{
var tileset = map.Tilesets[i];
if (!string.IsNullOrWhiteSpace(tileset.Source))
{
var directoryName = Path.GetDirectoryName(filename);
var tilesetLocation = tileset.Source.Replace('/', Path.DirectorySeparatorChar);
var filePath = Path.Combine(directoryName, tilesetLocation);
var normExtTilesetPath = new DirectoryInfo(filePath).FullName;
context.Logger.LogMessage("Reading External Tileset File: " + normExtTilesetPath);
using (var file = new StreamReader(filePath))
{
map.Tilesets[i] = (TmxTileset)xmlSerializer.Deserialize(file);
map.Tilesets[i].FixImagePath(filename, tileset.Source);
map.Tilesets[i].FirstGid = tileset.FirstGid;
}
}
else
{
tileset.MapFolder = Path.GetDirectoryName(Path.GetFullPath(filename));
}
}
return(map);
}
}
public override Map Import(string filename, ContentImporterContext context)
{
// Uses XmlSerializer to load a map file
Map item = new Map();
FileStream sw = File.Open(filename, FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(Map));
item = (Map)serializer.Deserialize(sw);
sw.Close();
return(item);
}
public override IDictionary <string, object> Import(string filename, ContentImporterContext context)
{
Logger = context.Logger;
Logger.LogMessage("Importing uiskin file: {0}", filename);
using (var reader = new StreamReader(filename))
{
var ret = JsonConvert.DeserializeObject <IDictionary <string, object> >(reader.ReadToEnd(), new JsonConverter[] { new JsonDictionaryConverter() });
return(ret);
}
}
public override TextureContent Import(string filename, ContentImporterContext context)
{
Il.ilInit();
int imageId = Il.ilGenImage();
Il.ilBindImage(imageId);
Il.ilLoadImage(filename);
IntPtr data = Il.ilGetData();
return(null);
}
public override string Import(string filename, ContentImporterContext context)
{
//all we do is read in the whole file as a string and pass it to the processor.
string text = string.Empty;
using (StreamReader reader = new StreamReader(filename))
text = reader.ReadToEnd();
return(text);
}
public override VoxContent Import(string fileName, ContentImporterContext context)
{
m_ContentImporterContext = context;
m_strFileName = fileName;
using (var fileStream = File.OpenRead(fileName))
using (var binaryReader = new BinaryReader(fileStream))
{
return(ReadVoxFile(binaryReader));
}
}
public override TexturePackerFile Import(string filename, ContentImporterContext context)
{
using (var streamReader = new StreamReader(filename))
{
using (var jsonReader = new JsonTextReader(streamReader))
{
var serializer = new JsonSerializer();
return serializer.Deserialize<TexturePackerFile>(jsonReader);
}
}
}
public override TiledMapContent Import(string filename, ContentImporterContext context)
{
context.Logger.LogMessage("Importing TMX Map: {0}", filename);
XmlSerializer serializer = new XmlSerializer(typeof(TiledMapContent));
using (FileStream stream = new FileStream(filename, FileMode.Open))
{
TiledMapContent result = (TiledMapContent)serializer.Deserialize(stream);
return(result);
}
}
public override dynamic Import(string filename, ContentImporterContext context)
{
context.Logger.LogMessage("Importing spring file: {0}", filename);
using (var streamReader = new StreamReader(filename))
{
return(JsonConvert.DeserializeObject <dynamic>(streamReader.ReadToEnd()));
// JsonSerializer serializer = new JsonSerializer();
// return (dynamic)serializer.Deserialize(streamReader, typeof(dynamic));
}
}
public override string Import(string filename, ContentImporterContext context)
{
try
{
return(filename);
}
catch (Exception ex)
{
context.Logger.LogMessage("Error : {0}", ex);
throw;
}
}
private static List <SpriteContent> ImportTileset(XmlNode tileset, ContentImporterContext context, string baseDirectory)
{
List <SpriteContent> images = new List <SpriteContent>();
if (tileset["tileoffset"] != null)
{
throw new InvalidContentException("tileoffset is not supported.");
}
foreach (XmlNode tileNode in tileset.ChildNodes)
{
if (tileNode.Name != "tile")
{
continue;
}
var tileId = GetAttributeAsInt(tileNode, "id").Value;
if (tileId != images.Count)
{
throw new InvalidContentException("Invalid id");
}
XmlNode imageNode = tileNode["image"];
//var format = GetAttribute(imageNode, "format");
var imageSource = GetAttribute(imageNode, "source");
var fullImageSource = Path.Combine(baseDirectory, imageSource);
TextureImporter txImporter = new TextureImporter();
var textureContent = (Texture2DContent)txImporter.Import(fullImageSource, context);
textureContent.Name = Path.GetFileNameWithoutExtension(fullImageSource);
var source = new SpriteContent();
source.Texture = textureContent;
source.Bounds.Location = Point.Zero;
source.Bounds.Width = textureContent.Mipmaps[0].Width;
source.Bounds.Height = textureContent.Mipmaps[0].Height;
var transKeyColor = GetAttributeAsColor(imageNode, "trans");
if (transKeyColor != null)
{
foreach (var mips in textureContent.Faces)
{
foreach (var mip in mips)
{
((PixelBitmapContent <Color>)mip).ReplaceColor(transKeyColor.Value, Color.Transparent);
}
}
}
images.Add(source);
}
return(images);
}
public override ParticleDesignerContent Import(string filename, ContentImporterContext context)
{
context.Logger.LogMessage("\nImporting XML file: {0}", filename);
using (var streamReader = new StreamReader(filename))
{
var deserializer = new XmlSerializer(typeof(ParticleDesignerEmitterConfig));
var emitterConfig = (ParticleDesignerEmitterConfig)deserializer.Deserialize(streamReader);
return(new ParticleDesignerContent(context, emitterConfig));
}
}
public override TiledMap Import(string filename, ContentImporterContext context)
{
context.Logger.LogMessage("Importing JSON map: {0}", filename);
using (var file = File.OpenText(filename))
{
var serializer = new JsonSerializer();
var serializedMap = (TiledMap)serializer.Deserialize(file, typeof(TiledMap));
return(serializedMap);
}
}
public override SpriteSheetJSON Import(string filename, ContentImporterContext context)
{
context.Logger.LogMessage("Importing JSON file: {0}", filename);
using (var streamReader = new StreamReader(filename))
{
JObject o = JObject.Parse(streamReader.ReadToEnd());
streamReader.Close();
return(o.ToObject <SpriteSheetJSON>());
}
//throw new NotImplementedException();
}
public override TiledMap Import(string filename, ContentImporterContext context)
{
context.Logger.LogMessage(context.OutputDirectory);
using (var reader = new StreamReader(filename))
{
var jsonSerializer = new JsonSerializer();
var map = (TiledMap)jsonSerializer.Deserialize(reader, typeof(TiledMap));
LoadTilesets(filename, map, context);
return(map);
}
}
public override ImportContentData Import(string filename,
ContentImporterContext context)
{
Stream stream = File.OpenRead(Path.Combine("Content", filename));
XmlTextReader reader = new XmlTextReader(stream);
XmlSerializer serializer = new XmlSerializer(typeof(ParticleSequenceInfo));
ParticleSequenceInfo info =
(ParticleSequenceInfo)serializer.Deserialize(reader);
return(new ImportContentData(info));
}
public override TileSetData Import(string filename, ContentImporterContext context)
{
using (FileStream fileStream = new FileStream(filename, FileMode.Open))
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(TileSetData));
TileSetData data = xmlSerializer.Deserialize(fileStream) as TileSetData;
context.Logger.LogMessage(data.ToString());
return(data);
}
}
public override Project Import(string filename, ContentImporterContext context)
{
Project project;
using (FileStream fs = File.OpenRead(filename)) {
project = new Project(fs, new FileProjectResolver(filename));
}
//project.Filename = filename;
//project.Direcotry = filename.Remove(filename.LastIndexOf('\\'));
return(project);
}
public override BitmapFontFile Import(string filename, ContentImporterContext context)
{
context.Logger.LogMessage("Importing XML file: {0}", filename);
using (var stream = new FileStream(filename, FileMode.Open))
{
using (var streamReader = new StreamReader(stream))
{
var deserializer = new XmlSerializer(typeof(BitmapFontFile));
return((BitmapFontFile)deserializer.Deserialize(streamReader));
}
}
}
/// <summary>
/// Called by the framework when importing a game asset. This is the method called by XNA when
/// an asset is to be imported into an object that can be recognized by the Content Pipeline.
/// </summary>
/// <param name="filename">Name of a game asset file.</param>
/// <param name="context">
/// Contains information for importing a game asset, such as a logger interface.
/// </param>
/// <returns>Resulting game asset.</returns>
public override DRMaterialContent Import(string filename, ContentImporterContext context)
{
string name = Path.GetFileNameWithoutExtension(filename);
var identity = new ContentIdentity(filename);
var definition = XDocument.Load(filename, LoadOptions.SetLineInfo);
return(new DRMaterialContent
{
Name = name,
Identity = identity,
Definition = definition
});
}
public override BitmapFontFile Import(string filename, ContentImporterContext context)
{
context.Logger.LogMessage("Importing XML file: {0}", filename);
using (var streamReader = new StreamReader(filename))
{
var deserializer = new XmlSerializer(typeof(BitmapFontFile));
var bmFontFile = (BitmapFontFile)deserializer.Deserialize(streamReader);
bmFontFile.file = filename;
return(bmFontFile);
}
}
public override TextureContent Import(string filename, ContentImporterContext context)
{
//using (var stream = File.OpenRead(filename))
//{
// var ts = Tileset.FromStream(stream);
// var src = ts.ImagePath;
// if (!Path.IsPathRooted(src))
// src = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(filename), src));
// context.AddDependency(src);
// return new TextureImporter().Import(src, context);
//}
throw new NotImplementedException();
}
/// <inheritdoc />
public override string[] Import(string filename, ContentImporterContext context)
{
string[] filenames = File.ReadAllLines(filename);
string[] res = new string[filenames.Length];
string dir = Path.GetDirectoryName(filename) + Path.DirectorySeparatorChar;
for (int i = 0; i < res.Length; i++)
{
res[i] = dir + filenames[i];
}
return(res);
}
public override SpineImporterResult Import(string filename, ContentImporterContext context)
{
string atlas = null,
json = null,
texturePath = null;
using (var zipFile = new FileStream(filename, FileMode.Open))
{
using (var zipArchive = new ZipArchive(zipFile, ZipArchiveMode.Read))
{
foreach (var entry in zipArchive.Entries)
{
var extension = Path.GetExtension(entry.Name.ToLowerInvariant());
using (var stream = entry.Open())
{
switch (extension)
{
case ".atlas":
using (var reader = new StreamReader(stream))
atlas = reader.ReadToEnd();
break;
case ".json":
using (var reader = new StreamReader(stream))
json = reader.ReadToEnd();
break;
case ".jpg":
case ".bmp":
case ".png":
using (var mem = new MemoryStream())
{
stream.CopyTo(mem);
texturePath = Path.Combine(Path.GetTempPath(), entry.Name);
if (File.Exists(texturePath))
{
File.Delete(texturePath);
}
File.WriteAllBytes(texturePath, mem.ToArray());
}
break;
}
}
}
}
}
return(new SpineImporterResult(atlas, json, texturePath));
}
public override IntermediateModelDef Import(string filename, ContentImporterContext context)
{
sourceFilename = filename;
importerContext = context;
//DebugNow();
IntermediateModelDef imd = new IntermediateModelDef();
imd.Path = Path.Combine(context.IntermediateDirectory, filename);
IntermediateModelDef.Load(ref imd);
return(imd);
}
public override XDocument Import(string filename, ContentImporterContext context)
{
using (Stream stream = File.OpenRead(filename))
{
try
{
return(XDocument.Load(stream));
}
catch (Exception ex)
{
throw new InvalidContentException(ex.Message, ex);
}
}
}
public override CensorContent.CensorContentFile Import(string filename, ContentImporterContext context)
{
Logger logger = new Logger();
logger.Context = context;
StreamReader reader = new StreamReader(filename);
CensorContent.CensorContentFile file = CensorContent.ReadSourceRepresentation(reader, filename, logger);
reader.Close();
return(file);
}
public override ImportData Import(string filename, ContentImporterContext context)
{
ImportData data = new ImportData();
XDocument doc = XDocument.Load(filename);
var root = doc.Root;
data.RootControl = new ControlData();
data.RootControl.Name = root.Name.LocalName.ToLower();
data.RootControl.Attributes = LoadAttributes(root);
data.RootControl.Children = LoadChildren(root);
return(data);
}
public MapObjectLayerContent(XmlNode node, ContentImporterContext context)
: base(node, context)
{
if (node.Attributes["color"] != null)
{
// get the color string, removing the leading #
string color = node.Attributes["color"].Value.Substring(1);
// get the RGB individually
string r = color.Substring(0, 2);
string g = color.Substring(2, 2);
string b = color.Substring(4, 2);
// convert to the color
Color = new Color(
(byte)int.Parse(r, NumberStyles.AllowHexSpecifier),
(byte)int.Parse(g, NumberStyles.AllowHexSpecifier),
(byte)int.Parse(b, NumberStyles.AllowHexSpecifier));
}
foreach (XmlNode objectNode in node.SelectNodes("object"))
{
MapObjectContent mapObjectContent = new MapObjectContent(objectNode, context);
// Object names need to be unique for our lookup system, but Tiled
// doesn't require unique names.
string objectName = mapObjectContent.Name;
int duplicateCount = 2;
// if a object already has the same name...
if (Objects.Find(o => o.Name == objectName) != null)
{
// figure out a object name that does work
do
{
objectName = string.Format("{0}{1}", mapObjectContent.Name, duplicateCount);
duplicateCount++;
} while (Objects.Find(o => o.Name == objectName) != null);
// log a warning for the user to see
context.Logger.LogWarning(string.Empty, new ContentIdentity(), "Renaming object \"{0}\" to \"{1}\" in layer \"{2}\" to make a unique name.", mapObjectContent.Name, objectName, Name);
// save that name
mapObjectContent.Name = objectName;
}
Objects.Add(mapObjectContent);
}
}
public override AnimationData Import(string filename, ContentImporterContext context)
{
XmlDocument doc = new XmlDocument();
doc.Load(filename);
XmlNode root = doc.DocumentElement;
string sheet = "";
int fps = 0;
int w = 0;
int h = 0;
int row = 0;
int col = 0;
foreach (XmlNode node in root.ChildNodes)
{
switch (node.Name)
{
case "sheet":
sheet = node.InnerText;
break;
case "fps":
fps = Int32.Parse(node.InnerText);
break;
case "width":
w = Int32.Parse(node.InnerText);
break;
case "height":
h = Int32.Parse(node.InnerText);
break;
case "row":
row = Int32.Parse(node.InnerText);
break;
case "col":
col = Int32.Parse(node.InnerText);
break;
default:
throw new Exception(node.Value);
}
}
return(new AnimationData(sheet, fps, w, h, row, col));
}
public override bool Execute()
{
Log.LogMessage("Building content:");
XBuildLogger logger = new XBuildLogger(this.Log);
ContentCompiler compiler = new ContentCompiler(PipelineAssemblies);
foreach (ITaskItem sourceItem in SourceAssets)
{
//foreach (string name in sourceItem.MetadataNames)
// Log.LogMessage(name + " : " + sourceItem.GetMetadata(name));
string assetName = sourceItem.GetMetadata("Name");
Log.LogMessage("Building " + assetName);
Stream outputStream = new FileStream(OutputDirectory + assetName + ".xnb", FileMode.OpenOrCreate);
ContentWriter contentWriter = new ContentWriter(outputStream, getTargetPlatform(), CompressContent);
string importerName = sourceItem.GetMetadata("Importer");
string processorName = sourceItem.GetMetadata("Processor");
IContentImporter importer = getImporterInstance(importerName);
if (importer == null)
Log.LogError("Could not find the importer (" + importerName + ")");
IContentProcessor processor = getProcessorInstance(processorName);
if (importer == null)
Log.LogError("Could not find the processor (" + processorName + ")");
Log.LogMessage("Using " + importerName + " and " + processorName);
ContentImporterContext importerContext = new ContentImporterContext(this, IntermediateDirectory, OutputDirectory, logger);
ContentProcessorContext processorContext = new ContentProcessorContext();
processor.Process(importer.Import(sourceItem.GetMetadata("Include"), importerContext), processorContext);
}
return true;
}
