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; }