OniSplit/Motoko/TextureXmlImporter.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Xml;
using Oni.Imaging;
using Oni.Metadata;
using Oni.Xml;

namespace Oni.Motoko
{
    internal class TextureXmlImporter
    {
        private readonly XmlImporter importer;
        private readonly XmlReader xml;
        private readonly string filePath;

        public TextureXmlImporter(XmlImporter importer, XmlReader xml, string filePath)
        {
            this.importer = importer;
            this.xml = xml;
            this.filePath = filePath;
        }

        public void Import()
        {
            xml.ReadStartElement();

            var name = Importer.DecodeFileName(Path.GetFileNameWithoutExtension(filePath));
            var flags = MetaEnum.Parse<InstanceMetadata.TXMPFlags>(xml.ReadElementContentAsString("Flags", ""));
            var format = MetaEnum.Parse<InstanceMetadata.TXMPFormat>(xml.ReadElementContentAsString("Format", ""));

            int width = 0;
            int height = 0;
            int speed = 1;

            if (xml.IsStartElement("Width"))
                width = xml.ReadElementContentAsInt();

            if (xml.IsStartElement("Height"))
                height = xml.ReadElementContentAsInt();

            string envMapName = null;

            if (xml.IsStartElement("EnvMap"))
            {
                envMapName = xml.ReadElementContentAsString();

                if (envMapName != null && envMapName.Length == 0)
                    envMapName = null;
            }

            if (xml.IsStartElement("Speed"))
                speed = xml.ReadElementContentAsInt();

            var imageFilePaths = new List<string>();
            var inputDirPath = Path.GetDirectoryName(filePath);

            while (xml.IsStartElement("Image"))
            {
                string imageFilePath = xml.ReadElementContentAsString();

                if (!Path.IsPathRooted(imageFilePath))
                    imageFilePath = Path.Combine(inputDirPath, imageFilePath);

                if (!File.Exists(imageFilePath))
                    throw new IOException(string.Format("Could not find image file '{0}'", imageFilePath));

                imageFilePaths.Add(imageFilePath);
            }

            xml.ReadEndElement();

            var surfaces = new List<Surface>();

            foreach (string imageFilePath in imageFilePaths)
                surfaces.Add(TgaReader.Read(imageFilePath));

            if (surfaces.Count == 0)
                throw new InvalidDataException("No images found. A texture must have at least one image.");

            int imageWidth = 0;
            int imageHeight = 0;

            foreach (Surface surface in surfaces)
            {
                if (imageWidth == 0)
                    imageWidth = surface.Width;
                else if (imageWidth != surface.Width)
                    throw new NotSupportedException("All animation frames must have the same size.");

                if (imageHeight == 0)
                    imageHeight = surface.Height;
                else if (imageHeight != surface.Height)
                    throw new NotSupportedException("All animation frames must have the same size.");
            }

            if (width == 0)
                width = imageWidth;
            else if (width > imageWidth)
                throw new NotSupportedException("Cannot upscale images.");

            if (height == 0)
                height = imageHeight;
            else if (height > imageHeight)
                throw new NotSupportedException("Cannot upscale images.");

            //if (envMapName != null && surfaces.Count > 1)
            //    throw new NotSupportedException("Animated textures cannot have an environment map.");

            if (width != imageWidth || height != imageHeight)
            {
                for (int i = 0; i < surfaces.Count; i++)
                    surfaces[i] = surfaces[i].Resize(width, height);
            }

            flags |= InstanceMetadata.TXMPFlags.SwapBytes;

            if (envMapName != null)
                flags |= InstanceMetadata.TXMPFlags.HasEnvMap;

            for (int i = 0; i < surfaces.Count; i++)
            {
                BinaryWriter writer;

                if (i == 0)
                    writer = importer.BeginXmlInstance(TemplateTag.TXMP, name, i.ToString(CultureInfo.InvariantCulture));
                else
                    writer = importer.BeginXmlInstance(TemplateTag.TXMP, null, i.ToString(CultureInfo.InvariantCulture));

                writer.Skip(128);
                writer.Write((int)flags);
                writer.WriteUInt16(width);
                writer.WriteUInt16(height);
                writer.Write((int)format);

                if (i == 0 && surfaces.Count > 1)
                    writer.WriteInstanceId(surfaces.Count);
                else
                    writer.Write(0);

                if (envMapName != null)
                    writer.WriteInstanceId(surfaces.Count + ((surfaces.Count > 1) ? 1 : 0));
                else
                    writer.Write(0);

                writer.Write(importer.RawWriter.Align32());
                writer.Skip(12);

                var mainSurface = surfaces[i];

                var levels = new List<Surface> { mainSurface };

                if ((flags & InstanceMetadata.TXMPFlags.HasMipMaps) != 0)
                {
                    int mipWidth = width;
                    int mipHeight = height;

                    while (mipWidth > 1 || mipHeight > 1)
                    {
                        mipWidth = Math.Max(mipWidth >> 1, 1);
                        mipHeight = Math.Max(mipHeight >> 1, 1);

                        levels.Add(mainSurface.Resize(mipWidth, mipHeight));
                    }
                }

                foreach (var level in levels)
                {
                    var surface = level.Convert(TextureFormatToSurfaceFormat(format));
                    importer.RawWriter.Write(surface.Data);
                }

                importer.EndXmlInstance();
            }

            if (surfaces.Count > 1)
            {
                var txan = importer.CreateInstance(TemplateTag.TXAN);

                using (var writer = txan.OpenWrite(12))
                {
                    writer.WriteInt16(speed);
                    writer.WriteInt16(speed);
                    writer.Write(0);
                    writer.Write(surfaces.Count);
                    writer.Write(0);

                    for (int i = 1; i < surfaces.Count; i++)
                        writer.WriteInstanceId(i);
                }
            }

            if (envMapName != null)
            {
                importer.CreateInstance(TemplateTag.TXMP, envMapName);
            }
        }

        private static SurfaceFormat TextureFormatToSurfaceFormat(InstanceMetadata.TXMPFormat format)
        {
            switch (format)
            {
                case InstanceMetadata.TXMPFormat.BGRA4444:
                    return SurfaceFormat.BGRA4444;

                case InstanceMetadata.TXMPFormat.BGR555:
                    return SurfaceFormat.BGRX5551;

                case InstanceMetadata.TXMPFormat.BGRA5551:
                    return SurfaceFormat.BGRA5551;

                case InstanceMetadata.TXMPFormat.RGBA:
                    return SurfaceFormat.RGBA;

                case InstanceMetadata.TXMPFormat.BGR:
                    return SurfaceFormat.BGRX;

                case InstanceMetadata.TXMPFormat.DXT1:
                    return SurfaceFormat.DXT1;

                default:
                    throw new NotSupportedException(string.Format("Texture format {0} is not supported", format));
            }
        }
    }
}
Revision:	1114
Committed:	Wed Jan 22 14:08:57 2020 UTC (5 years, 8 months ago) by iritscen
File size:	8019 byte(s)
Log Message:	Adding OniSplit source code (v0.9.99.0). Many thanks to Neo for all his work over the years.
#	Content
1	using System;
2	using System.Collections.Generic;
3	using System.Globalization;
4	using System.IO;
5	using System.Xml;
6	using Oni.Imaging;
7	using Oni.Metadata;
8	using Oni.Xml;
9
10	namespace Oni.Motoko
11	{
12	internal class TextureXmlImporter
13	{
14	private readonly XmlImporter importer;
15	private readonly XmlReader xml;
16	private readonly string filePath;
17
18	public TextureXmlImporter(XmlImporter importer, XmlReader xml, string filePath)
19	{
20	this.importer = importer;
21	this.xml = xml;
22	this.filePath = filePath;
23	}
24
25	public void Import()
26	{
27	xml.ReadStartElement();
28
29	var name = Importer.DecodeFileName(Path.GetFileNameWithoutExtension(filePath));
30	var flags = MetaEnum.Parse<InstanceMetadata.TXMPFlags>(xml.ReadElementContentAsString("Flags", ""));
31	var format = MetaEnum.Parse<InstanceMetadata.TXMPFormat>(xml.ReadElementContentAsString("Format", ""));
32
33	int width = 0;
34	int height = 0;
35	int speed = 1;
36
37	if (xml.IsStartElement("Width"))
38	width = xml.ReadElementContentAsInt();
39
40	if (xml.IsStartElement("Height"))
41	height = xml.ReadElementContentAsInt();
42
43	string envMapName = null;
44
45	if (xml.IsStartElement("EnvMap"))
46	{
47	envMapName = xml.ReadElementContentAsString();
48
49	if (envMapName != null && envMapName.Length == 0)
50	envMapName = null;
51	}
52
53	if (xml.IsStartElement("Speed"))
54	speed = xml.ReadElementContentAsInt();
55
56	var imageFilePaths = new List<string>();
57	var inputDirPath = Path.GetDirectoryName(filePath);
58
59	while (xml.IsStartElement("Image"))
60	{
61	string imageFilePath = xml.ReadElementContentAsString();
62
63	if (!Path.IsPathRooted(imageFilePath))
64	imageFilePath = Path.Combine(inputDirPath, imageFilePath);
65
66	if (!File.Exists(imageFilePath))
67	throw new IOException(string.Format("Could not find image file '{0}'", imageFilePath));
68
69	imageFilePaths.Add(imageFilePath);
70	}
71
72	xml.ReadEndElement();
73
74	var surfaces = new List<Surface>();
75
76	foreach (string imageFilePath in imageFilePaths)
77	surfaces.Add(TgaReader.Read(imageFilePath));
78
79	if (surfaces.Count == 0)
80	throw new InvalidDataException("No images found. A texture must have at least one image.");
81
82	int imageWidth = 0;
83	int imageHeight = 0;
84
85	foreach (Surface surface in surfaces)
86	{
87	if (imageWidth == 0)
88	imageWidth = surface.Width;
89	else if (imageWidth != surface.Width)
90	throw new NotSupportedException("All animation frames must have the same size.");
91
92	if (imageHeight == 0)
93	imageHeight = surface.Height;
94	else if (imageHeight != surface.Height)
95	throw new NotSupportedException("All animation frames must have the same size.");
96	}
97
98	if (width == 0)
99	width = imageWidth;
100	else if (width > imageWidth)
101	throw new NotSupportedException("Cannot upscale images.");
102
103	if (height == 0)
104	height = imageHeight;
105	else if (height > imageHeight)
106	throw new NotSupportedException("Cannot upscale images.");
107
108	//if (envMapName != null && surfaces.Count > 1)
109	// throw new NotSupportedException("Animated textures cannot have an environment map.");
110
111	if (width != imageWidth \|\| height != imageHeight)
112	{
113	for (int i = 0; i < surfaces.Count; i++)
114	surfaces[i] = surfaces[i].Resize(width, height);
115	}
116
117	flags \|= InstanceMetadata.TXMPFlags.SwapBytes;
118
119	if (envMapName != null)
120	flags \|= InstanceMetadata.TXMPFlags.HasEnvMap;
121
122	for (int i = 0; i < surfaces.Count; i++)
123	{
124	BinaryWriter writer;
125
126	if (i == 0)
127	writer = importer.BeginXmlInstance(TemplateTag.TXMP, name, i.ToString(CultureInfo.InvariantCulture));
128	else
129	writer = importer.BeginXmlInstance(TemplateTag.TXMP, null, i.ToString(CultureInfo.InvariantCulture));
130
131	writer.Skip(128);
132	writer.Write((int)flags);
133	writer.WriteUInt16(width);
134	writer.WriteUInt16(height);
135	writer.Write((int)format);
136
137	if (i == 0 && surfaces.Count > 1)
138	writer.WriteInstanceId(surfaces.Count);
139	else
140	writer.Write(0);
141
142	if (envMapName != null)
143	writer.WriteInstanceId(surfaces.Count + ((surfaces.Count > 1) ? 1 : 0));
144	else
145	writer.Write(0);
146
147	writer.Write(importer.RawWriter.Align32());
148	writer.Skip(12);
149
150	var mainSurface = surfaces[i];
151
152	var levels = new List<Surface> { mainSurface };
153
154	if ((flags & InstanceMetadata.TXMPFlags.HasMipMaps) != 0)
155	{
156	int mipWidth = width;
157	int mipHeight = height;
158
159	while (mipWidth > 1 \|\| mipHeight > 1)
160	{
161	mipWidth = Math.Max(mipWidth >> 1, 1);
162	mipHeight = Math.Max(mipHeight >> 1, 1);
163
164	levels.Add(mainSurface.Resize(mipWidth, mipHeight));
165	}
166	}
167
168	foreach (var level in levels)
169	{
170	var surface = level.Convert(TextureFormatToSurfaceFormat(format));
171	importer.RawWriter.Write(surface.Data);
172	}
173
174	importer.EndXmlInstance();
175	}
176
177	if (surfaces.Count > 1)
178	{
179	var txan = importer.CreateInstance(TemplateTag.TXAN);
180
181	using (var writer = txan.OpenWrite(12))
182	{
183	writer.WriteInt16(speed);
184	writer.WriteInt16(speed);
185	writer.Write(0);
186	writer.Write(surfaces.Count);
187	writer.Write(0);
188
189	for (int i = 1; i < surfaces.Count; i++)
190	writer.WriteInstanceId(i);
191	}
192	}
193
194	if (envMapName != null)
195	{
196	importer.CreateInstance(TemplateTag.TXMP, envMapName);
197	}
198	}
199
200	private static SurfaceFormat TextureFormatToSurfaceFormat(InstanceMetadata.TXMPFormat format)
201	{
202	switch (format)
203	{
204	case InstanceMetadata.TXMPFormat.BGRA4444:
205	return SurfaceFormat.BGRA4444;
206
207	case InstanceMetadata.TXMPFormat.BGR555:
208	return SurfaceFormat.BGRX5551;
209
210	case InstanceMetadata.TXMPFormat.BGRA5551:
211	return SurfaceFormat.BGRA5551;
212
213	case InstanceMetadata.TXMPFormat.RGBA:
214	return SurfaceFormat.RGBA;
215
216	case InstanceMetadata.TXMPFormat.BGR:
217	return SurfaceFormat.BGRX;
218
219	case InstanceMetadata.TXMPFormat.DXT1:
220	return SurfaceFormat.DXT1;
221
222	default:
223	throw new NotSupportedException(string.Format("Texture format {0} is not supported", format));
224	}
225	}
226	}
227	}