OniSplit/Akira/AkiraDaeWriter.cs

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

namespace Oni.Akira
{
    internal class AkiraDaeWriter
    {
        #region Private data
        private readonly PolygonMesh source;
        private DaeSceneBuilder world;
        private DaeSceneBuilder worldMarkers;
        private DaeSceneBuilder[] objects;
        private DaeSceneBuilder rooms;
        private Dictionary<int, DaeSceneBuilder> scripts;

        private static readonly string[] objectTypeNames = new[] {
            "",
            "char",
            "patr",
            "door",
            "flag",
            "furn",
            "",
            "",
            "part",
            "pwru",
            "sndg",
            "trgv",
            "weap",
            "trig",
            "turr",
            "cons",
            "cmbt",
            "mele",
            "neut"
        };

        #endregion

        #region private class DaePolygon

        private class DaePolygon
        {
            private readonly Polygon source;
            private readonly Material material;
            private readonly int[] pointIndices;
            private readonly int[] texCoordIndices;
            private readonly int[] colorIndices;

            public DaePolygon(Polygon source, int[] pointIndices, int[] texCoordIndices, int[] colorIndices)
            {
                this.source = source;
                material = source.Material;
                this.pointIndices = pointIndices;
                this.texCoordIndices = texCoordIndices;
                this.colorIndices = colorIndices;
            }

            public DaePolygon(Material material, int[] pointIndices, int[] texCoordIndices)
            {
                this.material = material;
                this.pointIndices = pointIndices;
                this.texCoordIndices = texCoordIndices;
            }

            public Polygon Source => source;
            public Material Material => material;
            public int[] PointIndices => pointIndices;
            public int[] TexCoordIndices => texCoordIndices;
            public int[] ColorIndices => colorIndices;
        }

        #endregion
        #region private class DaeMeshBuilder

        private class DaeMeshBuilder
        {
            private readonly List<DaePolygon> polygons = new List<DaePolygon>();
            private readonly List<Vector3> points = new List<Vector3>();
            private readonly Dictionary<Vector3, int> uniquePoints = new Dictionary<Vector3, int>();
            private readonly List<Vector2> texCoords = new List<Vector2>();
            private readonly Dictionary<Vector2, int> uniqueTexCoords = new Dictionary<Vector2, int>();
            private readonly List<Color> colors = new List<Color>();
            private readonly Dictionary<Color, int> uniqueColors = new Dictionary<Color, int>();
            private string name;
            private Vector3 translation;
            private Dae.Geometry geometry;

            public DaeMeshBuilder(string name)
            {
                this.name = name;
            }

            public string Name
            {
                get { return name; }
                set { name = value; }
            }

            public Vector3 Translation => translation;

            public void ResetTransform()
            {
                //
                // Attempt to un-bake the translation of the furniture
                //

                var center = BoundingSphere.CreateFromPoints(points).Center;
                center.Y = BoundingBox.CreateFromPoints(points).Min.Y;

                translation = center;

                for (int i = 0; i < points.Count; i++)
                    points[i] -= center;
            }

            public void AddPolygon(Material material, Vector3[] polygonPoints, Vector2[] polygonTexCoords)
            {
                polygons.Add(new DaePolygon(
                    material,
                    Remap(polygonPoints, points, uniquePoints),
                    Remap(polygonTexCoords, texCoords, uniqueTexCoords)));
            }

            public void AddPolygon(Polygon polygon)
            {
                polygons.Add(new DaePolygon(
                    polygon,
                    Remap(polygon.Mesh.Points, polygon.PointIndices, points, uniquePoints),
                    Remap(polygon.Mesh.TexCoords, polygon.TexCoordIndices, texCoords, uniqueTexCoords),
                    Remap(polygon.Colors, colors, uniqueColors)));
            }

            public IEnumerable<Polygon> Polygons
            {
                get
                {
                    return from p in polygons
                           where p.Source != null
                           select p.Source;
                }
            }

            private static int[] Remap<T>(IList<T> values, int[] indices, List<T> list, Dictionary<T, int> unique)
                where T : struct
            {
                var result = new int[indices.Length];

                for (int i = 0; i < indices.Length; i++)
                    result[i] = AddUnique(list, unique, values[indices[i]]);

                return result;
            }

            private static int[] Remap<T>(IList<T> values, List<T> list, Dictionary<T, int> unique)
                where T : struct
            {
                var result = new int[values.Count];

                for (int i = 0; i < values.Count; i++)
                    result[i] = AddUnique(list, unique, values[i]);

                return result;
            }

            private static int AddUnique<T>(List<T> list, Dictionary<T, int> unique, T value)
                where T : struct
            {
                int index;

                if (!unique.TryGetValue(value, out index))
                {
                    index = list.Count;
                    unique.Add(value, index);
                    list.Add(value);
                }

                return index;
            }

            public void Build()
            {
                geometry = new Dae.Geometry();
                geometry.Name = Name + "_geo";

                var positionSource = new Dae.Source(points);
                var texCoordSource = new Dae.Source(texCoords);
                var colorSource = new Dae.Source(ColorArrayToFloatArray(colors), 4);

                geometry.Vertices.Add(new Dae.Input(Dae.Semantic.Position, positionSource));

                Dae.IndexedInput posInput = null;
                Dae.IndexedInput texCoordInput = null;
                Dae.IndexedInput colorInput = null;

                var materialPrimitives = new Dictionary<Material, Dae.MeshPrimitives>();

                polygons.Sort((x, y) => string.Compare(x.Material.Name, y.Material.Name));

                foreach (var poly in polygons)
                {
                    Dae.MeshPrimitives primitives;

                    if (!materialPrimitives.TryGetValue(poly.Material, out primitives))
                    {
                        primitives = new Dae.MeshPrimitives(Dae.MeshPrimitiveType.Polygons);
                        materialPrimitives.Add(poly.Material, primitives);

                        posInput = new Dae.IndexedInput(Dae.Semantic.Position, positionSource);
                        primitives.Inputs.Add(posInput);

                        texCoordInput = new Dae.IndexedInput(Dae.Semantic.TexCoord, texCoordSource);
                        primitives.Inputs.Add(texCoordInput);

                        if (poly.ColorIndices != null /*&& !poly.Material.Image.HasAlpha*/)
                        {
                            colorInput = new Dae.IndexedInput(Dae.Semantic.Color, colorSource);
                            primitives.Inputs.Add(colorInput);
                        }

                        primitives.MaterialSymbol = poly.Material.Name;
                        geometry.Primitives.Add(primitives);
                    }

                    primitives.VertexCounts.Add(poly.PointIndices.Length);

                    posInput.Indices.AddRange(poly.PointIndices);
                    texCoordInput.Indices.AddRange(poly.TexCoordIndices);

                    if (colorInput != null)
                    {
                        //
                        // If the first polygon had color indices then the rest better have them too...
                        //

                        colorInput.Indices.AddRange(poly.ColorIndices);
                    }
                }
            }

            public Dae.Geometry Geometry => geometry;

            public void InstantiateMaterials(Dae.GeometryInstance inst, DaeSceneBuilder sceneBuilder)
            {
                var matInstances = new Dictionary<Material, Dae.MaterialInstance>();

                foreach (var poly in polygons)
                {
                    if (matInstances.ContainsKey(poly.Material))
                        continue;

                    string matSymbol = poly.Material.Name;

                    var matInstance = new Dae.MaterialInstance(
                        matSymbol,
                        sceneBuilder.GetMaterial(poly.Material));

                    matInstances.Add(poly.Material, matInstance);

                    var primitives = geometry.Primitives.FirstOrDefault(p => p.MaterialSymbol == matSymbol);

                    if (primitives == null)
                        continue;

                    var texCoordInput = primitives.Inputs.Find(i => i.Semantic == Dae.Semantic.TexCoord);

                    if (texCoordInput == null)
                        continue;

                    matInstance.Bindings.Add(new Dae.MaterialBinding("diffuse_TEXCOORD", texCoordInput));
                    inst.Materials.Add(matInstance);
                }
            }

            private static float[] ColorArrayToFloatArray(IList<Color> array)
            {
                var result = new float[array.Count * 4];

                for (int i = 0; i < array.Count; i++)
                {
                    var color = array[i].ToVector3();

                    result[i * 4 + 0] = color.X;
                    result[i * 4 + 1] = color.Y;
                    result[i * 4 + 2] = color.Z;
                }

                return result;
            }
        }

        #endregion
        #region private class DaeSceneBuilder

        private class DaeSceneBuilder
        {
            private readonly Dae.Scene scene;
            private readonly Dictionary<string, DaeMeshBuilder> nameMeshBuilder;
            private readonly List<DaeMeshBuilder> meshBuilders;
            private readonly Dictionary<Material, Dae.Material> materials;
            private string imagesFolder = "images";

            public DaeSceneBuilder()
            {
                scene = new Dae.Scene();
                nameMeshBuilder = new Dictionary<string, DaeMeshBuilder>(StringComparer.Ordinal);
                meshBuilders = new List<DaeMeshBuilder>();
                materials = new Dictionary<Material, Dae.Material>();
            }

            public string ImagesFolder
            {
                get { return imagesFolder; }
                set { imagesFolder = value; }
            }

            public DaeMeshBuilder GetMeshBuilder(string name)
            {
                DaeMeshBuilder result;

                if (!nameMeshBuilder.TryGetValue(name, out result))
                {
                    result = new DaeMeshBuilder(name);
                    nameMeshBuilder.Add(name, result);
                    meshBuilders.Add(result);
                }

                return result;
            }

            public IEnumerable<DaeMeshBuilder> MeshBuilders => meshBuilders;

            public Dae.Material GetMaterial(Material material)
            {
                Dae.Material result;

                if (!materials.TryGetValue(material, out result))
                {
                    result = new Dae.Material();
                    materials.Add(material, result);
                }

                return result;
            }

            public void Build()
            {
                BuildNodes();
                BuildMaterials();
            }

            private void BuildNodes()
            {
                foreach (var meshBuilder in meshBuilders)
                {
                    meshBuilder.Build();

                    var instance = new Dae.GeometryInstance(meshBuilder.Geometry);

                    meshBuilder.InstantiateMaterials(instance, this);

                    var node = new Dae.Node();
                    node.Name = meshBuilder.Name;
                    node.Instances.Add(instance);

                    if (meshBuilder.Translation != Vector3.Zero)
                        node.Transforms.Add(new Dae.TransformTranslate(meshBuilder.Translation));

                    scene.Nodes.Add(node);
                }
            }

            private void BuildMaterials()
            {
                foreach (var pair in materials)
                {
                    var material = pair.Key;
                    var daeMaterial = pair.Value;

                    string imageFileName = GetImageFileName(material);

                    var image = new Dae.Image
                    {
                        FilePath = "./" + imageFileName.Replace('\\', '/'),
                        Name = material.Name + "_img"
                    };

                    var effectSurface = new Dae.EffectSurface(image);

                    var effectSampler = new Dae.EffectSampler(effectSurface)
                    {
                        //    WrapS = texture.WrapU ? Dae.EffectSamplerWrap.Wrap : Dae.EffectSamplerWrap.None,
                        //    WrapT = texture.WrapV ? Dae.EffectSamplerWrap.Wrap : Dae.EffectSamplerWrap.None
                    };

                    var effectTexture = new Dae.EffectTexture(effectSampler, "diffuse_TEXCOORD");

                    var effect = new Dae.Effect
                    {
                        Name = material.Name + "_fx",
                        AmbientValue = Vector4.One,
                        SpecularValue = Vector4.Zero,
                        DiffuseValue = effectTexture,
                        TransparentValue = material.Image.HasAlpha ? effectTexture : null,
                        Parameters = {
                            new Dae.EffectParameter("surface", effectSurface),
                            new Dae.EffectParameter("sampler", effectSampler)
                        }
                    };

                    daeMaterial.Name = material.Name;
                    daeMaterial.Effect = effect;
                }
            }

            private string GetImageFileName(Material material)
            {
                string fileName = material.Name + ".tga";

                if (material.IsMarker)
                    return Path.Combine("markers", fileName);

                return Path.Combine(imagesFolder, fileName);
            }

            public void Write(string filePath)
            {
                string outputDirPath = Path.GetDirectoryName(filePath);

                foreach (var material in materials.Keys)
                    TgaWriter.Write(material.Image, Path.Combine(outputDirPath, GetImageFileName(material)));

                Dae.Writer.WriteFile(filePath, scene);
            }
        }

        #endregion

        public static void WriteRooms(PolygonMesh mesh, string name, string outputDirPath)
        {
            var writer = new AkiraDaeWriter(mesh);
            writer.WriteRooms();
            writer.rooms.Write(Path.Combine(outputDirPath, name + "_bnv.dae"));
        }

        public static void WriteRooms(PolygonMesh mesh, string filePath)
        {
            var writer = new AkiraDaeWriter(mesh);
            writer.WriteRooms();
            writer.rooms.Write(filePath);
        }

        public static void Write(PolygonMesh mesh, string name, string outputDirPath, string fileType)
        {
            var writer = new AkiraDaeWriter(mesh);

            writer.WriteGeometry();
            writer.WriteRooms();

            writer.world.Write(Path.Combine(outputDirPath, name + "_env." + fileType));
            writer.worldMarkers.Write(Path.Combine(outputDirPath, name + "_env_markers." + fileType));
            writer.rooms.Write(Path.Combine(outputDirPath, name + "_bnv." + fileType));

            for (int i = 0; i < writer.objects.Length; i++)
            {
                var builder = writer.objects[i];

                if (builder != null)
                    builder.Write(Path.Combine(outputDirPath, string.Format("{0}_{1}." + fileType, name, objectTypeNames[i])));
            }

            foreach (var pair in writer.scripts)
            {
                var scriptId = pair.Key;
                var builder = pair.Value;

                builder.Write(Path.Combine(outputDirPath, string.Format("{0}_script_{1}." + fileType, name, scriptId)));
            }
        }

        private AkiraDaeWriter(PolygonMesh source)
        {
            this.source = source;
        }

        private void WriteGeometry()
        {
            world = new DaeSceneBuilder();
            worldMarkers = new DaeSceneBuilder();
            objects = new DaeSceneBuilder[objectTypeNames.Length];
            scripts = new Dictionary<int, DaeSceneBuilder>();

            foreach (var polygon in source.Polygons)
            {
                if (polygon.Material == null)
                    continue;

                int objectType = polygon.ObjectType;
                int scriptId = polygon.ScriptId;

                if (scriptId != 0)
                {
                    string name = string.Format(CultureInfo.InvariantCulture, "script_{0}", scriptId);

                    DaeSceneBuilder sceneBuilder;

                    if (!scripts.TryGetValue(scriptId, out sceneBuilder))
                    {
                        sceneBuilder = new DaeSceneBuilder();
                        scripts.Add(scriptId, sceneBuilder);
                    }

                    var meshBuilder = sceneBuilder.GetMeshBuilder(name);

                    meshBuilder.AddPolygon(polygon);
                }
                else if (objectType == -1)
                {
                    //
                    // If it doesn't have an object type then it's probably an environment polygon.
                    //

                    string name;

                    if (source.HasDebugInfo)
                        name = polygon.FileName;
                    else
                        name = "world";

                    DaeMeshBuilder meshBuilder;

                    if (polygon.Material.IsMarker)
                        meshBuilder = worldMarkers.GetMeshBuilder(name);
                    else
                        meshBuilder = world.GetMeshBuilder(name);

                    meshBuilder.AddPolygon(polygon);
                }
                else
                {
                    //
                    // This polygon belongs to a object. Export it to one of the object files.
                    //

                    string name = string.Format(CultureInfo.InvariantCulture,
                        "{0}_{1}", objectTypeNames[objectType], polygon.ObjectId);

                    var sceneBuilder = objects[objectType];

                    if (sceneBuilder == null)
                    {
                        sceneBuilder = new DaeSceneBuilder();
                        objects[objectType] = sceneBuilder;
                    }

                    var meshBuilder = sceneBuilder.GetMeshBuilder(name);

                    meshBuilder.AddPolygon(polygon);
                }
            }

            foreach (var sceneBuilder in objects)
            {
                if (sceneBuilder == null)
                    continue;

                foreach (var meshBuilder in sceneBuilder.MeshBuilders)
                {
                    meshBuilder.ResetTransform();

                    if (source.HasDebugInfo)
                    {
                        //
                        // Polygons that belong to an object have useful object names in the debug info.
                        // Try to use them. 
                        //

                        var names = new List<string>();
                        int objectId = 0;

                        foreach (var polygon in meshBuilder.Polygons)
                        {
                            objectId = polygon.ObjectId;
                            names.Add(polygon.ObjectName);
                        }

                        string name = Utils.CommonPrefix(names);

                        if (!string.IsNullOrEmpty(name) && name.Length > 3)
                        {
                            if (!name.EndsWith("_", StringComparison.Ordinal))
                                name += "_";

                            meshBuilder.Name = string.Format(CultureInfo.InvariantCulture,
                                "{0}{1}", name, objectId);
                        }
                    }
                }
            }

            foreach (var sceneBuilder in scripts.Values)
            {
                foreach (var meshBuilder in sceneBuilder.MeshBuilders)
                {
                    meshBuilder.ResetTransform();

                    if (source.HasDebugInfo)
                    {
                        //
                        // Polygons that belong to an object have useful object names in the debug info.
                        // Try to use them. 
                        //

                        var names = new List<string>();
                        int scriptId = 0;

                        foreach (var polygon in meshBuilder.Polygons)
                        {
                            scriptId = polygon.ScriptId;
                            names.Add(polygon.ObjectName);
                        }

                        string name = Utils.CommonPrefix(names);

                        if (!string.IsNullOrEmpty(name) && name.Length > 3)
                        {
                            if (!name.EndsWith("_", StringComparison.Ordinal))
                                name += "_";

                            meshBuilder.Name = string.Format(CultureInfo.InvariantCulture,
                                "{0}{1}", name, scriptId);
                        }
                    }
                }
            }

            world.Build();
            worldMarkers.Build();

            foreach (var sceneBuilder in objects)
            {
                if (sceneBuilder == null)
                    continue;

                sceneBuilder.Build();
            }

            foreach (var sceneBuilder in scripts.Values)
            {
                sceneBuilder.Build();
            }
        }

        private void WriteRooms()
        {
            rooms = new DaeSceneBuilder();
            rooms.ImagesFolder = "grids";

            for (int i = 0; i < source.Rooms.Count; i++)
            {
                var room = source.Rooms[i];

                var meshBuilder = rooms.GetMeshBuilder(
                    string.Format(CultureInfo.InvariantCulture, "room_{0}", i));

                var material = source.Materials.GetMaterial(
                    string.Format(CultureInfo.InvariantCulture, "bnv_grid_{0:d3}", i));

                material.Image = room.Grid.ToImage();

                foreach (var polygonPoints in room.GetFloorPolygons())
                {
                    var texCoords = new Vector2[polygonPoints.Length];

                    for (int j = 0; j < polygonPoints.Length; j++)
                    {
                        var point = polygonPoints[j];
                        var min = room.BoundingBox.Min;
                        var max = room.BoundingBox.Max;

                        min += new Vector3(room.Grid.TileSize * room.Grid.XOrigin, 0.0f, room.Grid.TileSize * room.Grid.ZOrigin);
                        max -= new Vector3(room.Grid.TileSize * room.Grid.XOrigin, 0.0f, room.Grid.TileSize * room.Grid.ZOrigin);

                        var size = max - min;

                        float x = (point.X - min.X) / size.X;
                        float z = (point.Z - min.Z) / size.Z;

                        texCoords[j] = new Vector2(x, z);
                    }

                    meshBuilder.AddPolygon(material, polygonPoints, texCoords);
                    meshBuilder.Build();
                }
            }

            var ghostTexCoords = new[] {
                new Vector2(0.0f, 0.0f),
                new Vector2(1.0f, 0.0f),
                new Vector2(1.0f, 1.0f),
                new Vector2(0.0f, 1.0f)
            };

            for (int i = 0; i < source.Ghosts.Count; i++)
            {
                var ghost = source.Ghosts[i];

                var meshBuilder = rooms.GetMeshBuilder(
                    string.Format(CultureInfo.InvariantCulture, "ghost_{0}", i));

                meshBuilder.AddPolygon(
                    source.Materials.Markers.Ghost,
                    ghost.Points.ToArray(),
                    ghostTexCoords);

                meshBuilder.Build();
                meshBuilder.ResetTransform();
            }

            rooms.Build();
        }
    }
}
Revision:	1114
Committed:	Wed Jan 22 14:08:57 2020 UTC (5 years, 8 months ago) by iritscen
File size:	26155 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 Oni.Imaging;
6
7	namespace Oni.Akira
8	{
9	internal class AkiraDaeWriter
10	{
11	#region Private data
12	private readonly PolygonMesh source;
13	private DaeSceneBuilder world;
14	private DaeSceneBuilder worldMarkers;
15	private DaeSceneBuilder[] objects;
16	private DaeSceneBuilder rooms;
17	private Dictionary<int, DaeSceneBuilder> scripts;
18
19	private static readonly string[] objectTypeNames = new[] {
20	"",
21	"char",
22	"patr",
23	"door",
24	"flag",
25	"furn",
26	"",
27	"",
28	"part",
29	"pwru",
30	"sndg",
31	"trgv",
32	"weap",
33	"trig",
34	"turr",
35	"cons",
36	"cmbt",
37	"mele",
38	"neut"
39	};
40
41	#endregion
42
43	#region private class DaePolygon
44
45	private class DaePolygon
46	{
47	private readonly Polygon source;
48	private readonly Material material;
49	private readonly int[] pointIndices;
50	private readonly int[] texCoordIndices;
51	private readonly int[] colorIndices;
52
53	public DaePolygon(Polygon source, int[] pointIndices, int[] texCoordIndices, int[] colorIndices)
54	{
55	this.source = source;
56	material = source.Material;
57	this.pointIndices = pointIndices;
58	this.texCoordIndices = texCoordIndices;
59	this.colorIndices = colorIndices;
60	}
61
62	public DaePolygon(Material material, int[] pointIndices, int[] texCoordIndices)
63	{
64	this.material = material;
65	this.pointIndices = pointIndices;
66	this.texCoordIndices = texCoordIndices;
67	}
68
69	public Polygon Source => source;
70	public Material Material => material;
71	public int[] PointIndices => pointIndices;
72	public int[] TexCoordIndices => texCoordIndices;
73	public int[] ColorIndices => colorIndices;
74	}
75
76	#endregion
77	#region private class DaeMeshBuilder
78
79	private class DaeMeshBuilder
80	{
81	private readonly List<DaePolygon> polygons = new List<DaePolygon>();
82	private readonly List<Vector3> points = new List<Vector3>();
83	private readonly Dictionary<Vector3, int> uniquePoints = new Dictionary<Vector3, int>();
84	private readonly List<Vector2> texCoords = new List<Vector2>();
85	private readonly Dictionary<Vector2, int> uniqueTexCoords = new Dictionary<Vector2, int>();
86	private readonly List<Color> colors = new List<Color>();
87	private readonly Dictionary<Color, int> uniqueColors = new Dictionary<Color, int>();
88	private string name;
89	private Vector3 translation;
90	private Dae.Geometry geometry;
91
92	public DaeMeshBuilder(string name)
93	{
94	this.name = name;
95	}
96
97	public string Name
98	{
99	get { return name; }
100	set { name = value; }
101	}
102
103	public Vector3 Translation => translation;
104
105	public void ResetTransform()
106	{
107	//
108	// Attempt to un-bake the translation of the furniture
109	//
110
111	var center = BoundingSphere.CreateFromPoints(points).Center;
112	center.Y = BoundingBox.CreateFromPoints(points).Min.Y;
113
114	translation = center;
115
116	for (int i = 0; i < points.Count; i++)
117	points[i] -= center;
118	}
119
120	public void AddPolygon(Material material, Vector3[] polygonPoints, Vector2[] polygonTexCoords)
121	{
122	polygons.Add(new DaePolygon(
123	material,
124	Remap(polygonPoints, points, uniquePoints),
125	Remap(polygonTexCoords, texCoords, uniqueTexCoords)));
126	}
127
128	public void AddPolygon(Polygon polygon)
129	{
130	polygons.Add(new DaePolygon(
131	polygon,
132	Remap(polygon.Mesh.Points, polygon.PointIndices, points, uniquePoints),
133	Remap(polygon.Mesh.TexCoords, polygon.TexCoordIndices, texCoords, uniqueTexCoords),
134	Remap(polygon.Colors, colors, uniqueColors)));
135	}
136
137	public IEnumerable<Polygon> Polygons
138	{
139	get
140	{
141	return from p in polygons
142	where p.Source != null
143	select p.Source;
144	}
145	}
146
147	private static int[] Remap<T>(IList<T> values, int[] indices, List<T> list, Dictionary<T, int> unique)
148	where T : struct
149	{
150	var result = new int[indices.Length];
151
152	for (int i = 0; i < indices.Length; i++)
153	result[i] = AddUnique(list, unique, values[indices[i]]);
154
155	return result;
156	}
157
158	private static int[] Remap<T>(IList<T> values, List<T> list, Dictionary<T, int> unique)
159	where T : struct
160	{
161	var result = new int[values.Count];
162
163	for (int i = 0; i < values.Count; i++)
164	result[i] = AddUnique(list, unique, values[i]);
165
166	return result;
167	}
168
169	private static int AddUnique<T>(List<T> list, Dictionary<T, int> unique, T value)
170	where T : struct
171	{
172	int index;
173
174	if (!unique.TryGetValue(value, out index))
175	{
176	index = list.Count;
177	unique.Add(value, index);
178	list.Add(value);
179	}
180
181	return index;
182	}
183
184	public void Build()
185	{
186	geometry = new Dae.Geometry();
187	geometry.Name = Name + "_geo";
188
189	var positionSource = new Dae.Source(points);
190	var texCoordSource = new Dae.Source(texCoords);
191	var colorSource = new Dae.Source(ColorArrayToFloatArray(colors), 4);
192
193	geometry.Vertices.Add(new Dae.Input(Dae.Semantic.Position, positionSource));
194
195	Dae.IndexedInput posInput = null;
196	Dae.IndexedInput texCoordInput = null;
197	Dae.IndexedInput colorInput = null;
198
199	var materialPrimitives = new Dictionary<Material, Dae.MeshPrimitives>();
200
201	polygons.Sort((x, y) => string.Compare(x.Material.Name, y.Material.Name));
202
203	foreach (var poly in polygons)
204	{
205	Dae.MeshPrimitives primitives;
206
207	if (!materialPrimitives.TryGetValue(poly.Material, out primitives))
208	{
209	primitives = new Dae.MeshPrimitives(Dae.MeshPrimitiveType.Polygons);
210	materialPrimitives.Add(poly.Material, primitives);
211
212	posInput = new Dae.IndexedInput(Dae.Semantic.Position, positionSource);
213	primitives.Inputs.Add(posInput);
214
215	texCoordInput = new Dae.IndexedInput(Dae.Semantic.TexCoord, texCoordSource);
216	primitives.Inputs.Add(texCoordInput);
217
218	if (poly.ColorIndices != null /&& !poly.Material.Image.HasAlpha/)
219	{
220	colorInput = new Dae.IndexedInput(Dae.Semantic.Color, colorSource);
221	primitives.Inputs.Add(colorInput);
222	}
223
224	primitives.MaterialSymbol = poly.Material.Name;
225	geometry.Primitives.Add(primitives);
226	}
227
228	primitives.VertexCounts.Add(poly.PointIndices.Length);
229
230	posInput.Indices.AddRange(poly.PointIndices);
231	texCoordInput.Indices.AddRange(poly.TexCoordIndices);
232
233	if (colorInput != null)
234	{
235	//
236	// If the first polygon had color indices then the rest better have them too...
237	//
238
239	colorInput.Indices.AddRange(poly.ColorIndices);
240	}
241	}
242	}
243
244	public Dae.Geometry Geometry => geometry;
245
246	public void InstantiateMaterials(Dae.GeometryInstance inst, DaeSceneBuilder sceneBuilder)
247	{
248	var matInstances = new Dictionary<Material, Dae.MaterialInstance>();
249
250	foreach (var poly in polygons)
251	{
252	if (matInstances.ContainsKey(poly.Material))
253	continue;
254
255	string matSymbol = poly.Material.Name;
256
257	var matInstance = new Dae.MaterialInstance(
258	matSymbol,
259	sceneBuilder.GetMaterial(poly.Material));
260
261	matInstances.Add(poly.Material, matInstance);
262
263	var primitives = geometry.Primitives.FirstOrDefault(p => p.MaterialSymbol == matSymbol);
264
265	if (primitives == null)
266	continue;
267
268	var texCoordInput = primitives.Inputs.Find(i => i.Semantic == Dae.Semantic.TexCoord);
269
270	if (texCoordInput == null)
271	continue;
272
273	matInstance.Bindings.Add(new Dae.MaterialBinding("diffuse_TEXCOORD", texCoordInput));
274	inst.Materials.Add(matInstance);
275	}
276	}
277
278	private static float[] ColorArrayToFloatArray(IList<Color> array)
279	{
280	var result = new float[array.Count * 4];
281
282	for (int i = 0; i < array.Count; i++)
283	{
284	var color = array[i].ToVector3();
285
286	result[i * 4 + 0] = color.X;
287	result[i * 4 + 1] = color.Y;
288	result[i * 4 + 2] = color.Z;
289	}
290
291	return result;
292	}
293	}
294
295	#endregion
296	#region private class DaeSceneBuilder
297
298	private class DaeSceneBuilder
299	{
300	private readonly Dae.Scene scene;
301	private readonly Dictionary<string, DaeMeshBuilder> nameMeshBuilder;
302	private readonly List<DaeMeshBuilder> meshBuilders;
303	private readonly Dictionary<Material, Dae.Material> materials;
304	private string imagesFolder = "images";
305
306	public DaeSceneBuilder()
307	{
308	scene = new Dae.Scene();
309	nameMeshBuilder = new Dictionary<string, DaeMeshBuilder>(StringComparer.Ordinal);
310	meshBuilders = new List<DaeMeshBuilder>();
311	materials = new Dictionary<Material, Dae.Material>();
312	}
313
314	public string ImagesFolder
315	{
316	get { return imagesFolder; }
317	set { imagesFolder = value; }
318	}
319
320	public DaeMeshBuilder GetMeshBuilder(string name)
321	{
322	DaeMeshBuilder result;
323
324	if (!nameMeshBuilder.TryGetValue(name, out result))
325	{
326	result = new DaeMeshBuilder(name);
327	nameMeshBuilder.Add(name, result);
328	meshBuilders.Add(result);
329	}
330
331	return result;
332	}
333
334	public IEnumerable<DaeMeshBuilder> MeshBuilders => meshBuilders;
335
336	public Dae.Material GetMaterial(Material material)
337	{
338	Dae.Material result;
339
340	if (!materials.TryGetValue(material, out result))
341	{
342	result = new Dae.Material();
343	materials.Add(material, result);
344	}
345
346	return result;
347	}
348
349	public void Build()
350	{
351	BuildNodes();
352	BuildMaterials();
353	}
354
355	private void BuildNodes()
356	{
357	foreach (var meshBuilder in meshBuilders)
358	{
359	meshBuilder.Build();
360
361	var instance = new Dae.GeometryInstance(meshBuilder.Geometry);
362
363	meshBuilder.InstantiateMaterials(instance, this);
364
365	var node = new Dae.Node();
366	node.Name = meshBuilder.Name;
367	node.Instances.Add(instance);
368
369	if (meshBuilder.Translation != Vector3.Zero)
370	node.Transforms.Add(new Dae.TransformTranslate(meshBuilder.Translation));
371
372	scene.Nodes.Add(node);
373	}
374	}
375
376	private void BuildMaterials()
377	{
378	foreach (var pair in materials)
379	{
380	var material = pair.Key;
381	var daeMaterial = pair.Value;
382
383	string imageFileName = GetImageFileName(material);
384
385	var image = new Dae.Image
386	{
387	FilePath = "./" + imageFileName.Replace('\\', '/'),
388	Name = material.Name + "_img"
389	};
390
391	var effectSurface = new Dae.EffectSurface(image);
392
393	var effectSampler = new Dae.EffectSampler(effectSurface)
394	{
395	// WrapS = texture.WrapU ? Dae.EffectSamplerWrap.Wrap : Dae.EffectSamplerWrap.None,
396	// WrapT = texture.WrapV ? Dae.EffectSamplerWrap.Wrap : Dae.EffectSamplerWrap.None
397	};
398
399	var effectTexture = new Dae.EffectTexture(effectSampler, "diffuse_TEXCOORD");
400
401	var effect = new Dae.Effect
402	{
403	Name = material.Name + "_fx",
404	AmbientValue = Vector4.One,
405	SpecularValue = Vector4.Zero,
406	DiffuseValue = effectTexture,
407	TransparentValue = material.Image.HasAlpha ? effectTexture : null,
408	Parameters = {
409	new Dae.EffectParameter("surface", effectSurface),
410	new Dae.EffectParameter("sampler", effectSampler)
411	}
412	};
413
414	daeMaterial.Name = material.Name;
415	daeMaterial.Effect = effect;
416	}
417	}
418
419	private string GetImageFileName(Material material)
420	{
421	string fileName = material.Name + ".tga";
422
423	if (material.IsMarker)
424	return Path.Combine("markers", fileName);
425
426	return Path.Combine(imagesFolder, fileName);
427	}
428
429	public void Write(string filePath)
430	{
431	string outputDirPath = Path.GetDirectoryName(filePath);
432
433	foreach (var material in materials.Keys)
434	TgaWriter.Write(material.Image, Path.Combine(outputDirPath, GetImageFileName(material)));
435
436	Dae.Writer.WriteFile(filePath, scene);
437	}
438	}
439
440	#endregion
441
442	public static void WriteRooms(PolygonMesh mesh, string name, string outputDirPath)
443	{
444	var writer = new AkiraDaeWriter(mesh);
445	writer.WriteRooms();
446	writer.rooms.Write(Path.Combine(outputDirPath, name + "_bnv.dae"));
447	}
448
449	public static void WriteRooms(PolygonMesh mesh, string filePath)
450	{
451	var writer = new AkiraDaeWriter(mesh);
452	writer.WriteRooms();
453	writer.rooms.Write(filePath);
454	}
455
456	public static void Write(PolygonMesh mesh, string name, string outputDirPath, string fileType)
457	{
458	var writer = new AkiraDaeWriter(mesh);
459
460	writer.WriteGeometry();
461	writer.WriteRooms();
462
463	writer.world.Write(Path.Combine(outputDirPath, name + "_env." + fileType));
464	writer.worldMarkers.Write(Path.Combine(outputDirPath, name + "_env_markers." + fileType));
465	writer.rooms.Write(Path.Combine(outputDirPath, name + "_bnv." + fileType));
466
467	for (int i = 0; i < writer.objects.Length; i++)
468	{
469	var builder = writer.objects[i];
470
471	if (builder != null)
472	builder.Write(Path.Combine(outputDirPath, string.Format("{0}_{1}." + fileType, name, objectTypeNames[i])));
473	}
474
475	foreach (var pair in writer.scripts)
476	{
477	var scriptId = pair.Key;
478	var builder = pair.Value;
479
480	builder.Write(Path.Combine(outputDirPath, string.Format("{0}_script_{1}." + fileType, name, scriptId)));
481	}
482	}
483
484	private AkiraDaeWriter(PolygonMesh source)
485	{
486	this.source = source;
487	}
488
489	private void WriteGeometry()
490	{
491	world = new DaeSceneBuilder();
492	worldMarkers = new DaeSceneBuilder();
493	objects = new DaeSceneBuilder[objectTypeNames.Length];
494	scripts = new Dictionary<int, DaeSceneBuilder>();
495
496	foreach (var polygon in source.Polygons)
497	{
498	if (polygon.Material == null)
499	continue;
500
501	int objectType = polygon.ObjectType;
502	int scriptId = polygon.ScriptId;
503
504	if (scriptId != 0)
505	{
506	string name = string.Format(CultureInfo.InvariantCulture, "script_{0}", scriptId);
507
508	DaeSceneBuilder sceneBuilder;
509
510	if (!scripts.TryGetValue(scriptId, out sceneBuilder))
511	{
512	sceneBuilder = new DaeSceneBuilder();
513	scripts.Add(scriptId, sceneBuilder);
514	}
515
516	var meshBuilder = sceneBuilder.GetMeshBuilder(name);
517
518	meshBuilder.AddPolygon(polygon);
519	}
520	else if (objectType == -1)
521	{
522	//
523	// If it doesn't have an object type then it's probably an environment polygon.
524	//
525
526	string name;
527
528	if (source.HasDebugInfo)
529	name = polygon.FileName;
530	else
531	name = "world";
532
533	DaeMeshBuilder meshBuilder;
534
535	if (polygon.Material.IsMarker)
536	meshBuilder = worldMarkers.GetMeshBuilder(name);
537	else
538	meshBuilder = world.GetMeshBuilder(name);
539
540	meshBuilder.AddPolygon(polygon);
541	}
542	else
543	{
544	//
545	// This polygon belongs to a object. Export it to one of the object files.
546	//
547
548	string name = string.Format(CultureInfo.InvariantCulture,
549	"{0}_{1}", objectTypeNames[objectType], polygon.ObjectId);
550
551	var sceneBuilder = objects[objectType];
552
553	if (sceneBuilder == null)
554	{
555	sceneBuilder = new DaeSceneBuilder();
556	objects[objectType] = sceneBuilder;
557	}
558
559	var meshBuilder = sceneBuilder.GetMeshBuilder(name);
560
561	meshBuilder.AddPolygon(polygon);
562	}
563	}
564
565	foreach (var sceneBuilder in objects)
566	{
567	if (sceneBuilder == null)
568	continue;
569
570	foreach (var meshBuilder in sceneBuilder.MeshBuilders)
571	{
572	meshBuilder.ResetTransform();
573
574	if (source.HasDebugInfo)
575	{
576	//
577	// Polygons that belong to an object have useful object names in the debug info.
578	// Try to use them.
579	//
580
581	var names = new List<string>();
582	int objectId = 0;
583
584	foreach (var polygon in meshBuilder.Polygons)
585	{
586	objectId = polygon.ObjectId;
587	names.Add(polygon.ObjectName);
588	}
589
590	string name = Utils.CommonPrefix(names);
591
592	if (!string.IsNullOrEmpty(name) && name.Length > 3)
593	{
594	if (!name.EndsWith("_", StringComparison.Ordinal))
595	name += "_";
596
597	meshBuilder.Name = string.Format(CultureInfo.InvariantCulture,
598	"{0}{1}", name, objectId);
599	}
600	}
601	}
602	}
603
604	foreach (var sceneBuilder in scripts.Values)
605	{
606	foreach (var meshBuilder in sceneBuilder.MeshBuilders)
607	{
608	meshBuilder.ResetTransform();
609
610	if (source.HasDebugInfo)
611	{
612	//
613	// Polygons that belong to an object have useful object names in the debug info.
614	// Try to use them.
615	//
616
617	var names = new List<string>();
618	int scriptId = 0;
619
620	foreach (var polygon in meshBuilder.Polygons)
621	{
622	scriptId = polygon.ScriptId;
623	names.Add(polygon.ObjectName);
624	}
625
626	string name = Utils.CommonPrefix(names);
627
628	if (!string.IsNullOrEmpty(name) && name.Length > 3)
629	{
630	if (!name.EndsWith("_", StringComparison.Ordinal))
631	name += "_";
632
633	meshBuilder.Name = string.Format(CultureInfo.InvariantCulture,
634	"{0}{1}", name, scriptId);
635	}
636	}
637	}
638	}
639
640	world.Build();
641	worldMarkers.Build();
642
643	foreach (var sceneBuilder in objects)
644	{
645	if (sceneBuilder == null)
646	continue;
647
648	sceneBuilder.Build();
649	}
650
651	foreach (var sceneBuilder in scripts.Values)
652	{
653	sceneBuilder.Build();
654	}
655	}
656
657	private void WriteRooms()
658	{
659	rooms = new DaeSceneBuilder();
660	rooms.ImagesFolder = "grids";
661
662	for (int i = 0; i < source.Rooms.Count; i++)
663	{
664	var room = source.Rooms[i];
665
666	var meshBuilder = rooms.GetMeshBuilder(
667	string.Format(CultureInfo.InvariantCulture, "room_{0}", i));
668
669	var material = source.Materials.GetMaterial(
670	string.Format(CultureInfo.InvariantCulture, "bnv_grid_{0:d3}", i));
671
672	material.Image = room.Grid.ToImage();
673
674	foreach (var polygonPoints in room.GetFloorPolygons())
675	{
676	var texCoords = new Vector2[polygonPoints.Length];
677
678	for (int j = 0; j < polygonPoints.Length; j++)
679	{
680	var point = polygonPoints[j];
681	var min = room.BoundingBox.Min;
682	var max = room.BoundingBox.Max;
683
684	min += new Vector3(room.Grid.TileSize * room.Grid.XOrigin, 0.0f, room.Grid.TileSize * room.Grid.ZOrigin);
685	max -= new Vector3(room.Grid.TileSize * room.Grid.XOrigin, 0.0f, room.Grid.TileSize * room.Grid.ZOrigin);
686
687	var size = max - min;
688
689	float x = (point.X - min.X) / size.X;
690	float z = (point.Z - min.Z) / size.Z;
691
692	texCoords[j] = new Vector2(x, z);
693	}
694
695	meshBuilder.AddPolygon(material, polygonPoints, texCoords);
696	meshBuilder.Build();
697	}
698	}
699
700	var ghostTexCoords = new[] {
701	new Vector2(0.0f, 0.0f),
702	new Vector2(1.0f, 0.0f),
703	new Vector2(1.0f, 1.0f),
704	new Vector2(0.0f, 1.0f)
705	};
706
707	for (int i = 0; i < source.Ghosts.Count; i++)
708	{
709	var ghost = source.Ghosts[i];
710
711	var meshBuilder = rooms.GetMeshBuilder(
712	string.Format(CultureInfo.InvariantCulture, "ghost_{0}", i));
713
714	meshBuilder.AddPolygon(
715	source.Materials.Markers.Ghost,
716	ghost.Points.ToArray(),
717	ghostTexCoords);
718
719	meshBuilder.Build();
720	meshBuilder.ResetTransform();
721	}
722
723	rooms.Build();
724	}
725	}
726	}