Index: /OniSplit/Akira/AkiraDaeNodeProperties.cs =================================================================== --- /OniSplit/Akira/AkiraDaeNodeProperties.cs (revision 1114) +++ /OniSplit/Akira/AkiraDaeNodeProperties.cs (revision 1114) @@ -0,0 +1,9 @@ +namespace Oni.Akira +{ + internal abstract class AkiraDaeNodeProperties + { + public bool HasPhysics; + public int ScriptId; + public GunkFlags GunkFlags; + } +} Index: /OniSplit/Akira/AkiraDaeReader.cs =================================================================== --- /OniSplit/Akira/AkiraDaeReader.cs (revision 1114) +++ /OniSplit/Akira/AkiraDaeReader.cs (revision 1114) @@ -0,0 +1,347 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class AkiraDaeReader + { + #region Private data + private readonly PolygonMesh mesh; + private readonly List positions; + private readonly Dictionary uniquePositions; + private readonly List normals; + private readonly List texCoords; + private readonly Dictionary materialMap; + private readonly Dictionary materialFileMap; + private readonly Stack nodeTransformStack; + + private Dae.Scene scene; + private Dictionary properties; + private Matrix nodeTransform; + private string nodeName; + #endregion + + public static PolygonMesh Read(IEnumerable filePaths) + { + var reader = new AkiraDaeReader(); + var properties = new Dictionary(); + + foreach (var filePath in filePaths) + reader.ReadScene(Dae.Reader.ReadFile(filePath), properties); + + return reader.mesh; + } + + public AkiraDaeReader() + { + mesh = new PolygonMesh(new MaterialLibrary()); + + positions = mesh.Points; + uniquePositions = new Dictionary(); + texCoords = mesh.TexCoords; + normals = mesh.Normals; + + materialMap = new Dictionary(); + materialFileMap = new Dictionary(StringComparer.OrdinalIgnoreCase); + + nodeTransformStack = new Stack(); + nodeTransform = Matrix.Identity; + } + + public PolygonMesh Mesh => mesh; + + public void ReadScene(Dae.Scene scene, Dictionary properties) + { + this.scene = scene; + this.properties = properties; + + AkiraDaeNodeProperties sceneProperties; + properties.TryGetValue(scene.Id, out sceneProperties); + + foreach (var node in scene.Nodes) + ReadNode(node, sceneProperties); + } + + private void ReadNode(Dae.Node node, AkiraDaeNodeProperties parentNodeProperties) + { + AkiraDaeNodeProperties nodeProperties; + + if (!properties.TryGetValue(node.Id, out nodeProperties)) + nodeProperties = parentNodeProperties; + else if (nodeProperties.HasPhysics) + return; + + nodeTransformStack.Push(nodeTransform); + + foreach (var transform in node.Transforms) + nodeTransform = transform.ToMatrix() * nodeTransform; + + nodeName = node.Name; + + foreach (var geometryInstance in node.GeometryInstances) + ReadGeometryInstance(node, nodeProperties, geometryInstance); + + foreach (var child in node.Nodes) + ReadNode(child, nodeProperties); + + nodeTransform = nodeTransformStack.Pop(); + } + + private void ReadGeometryInstance(Dae.Node node, AkiraDaeNodeProperties nodeProperties, Dae.GeometryInstance instance) + { + foreach (var primitives in instance.Target.Primitives) + { + if (primitives.PrimitiveType != Dae.MeshPrimitiveType.Polygons) + { + Console.Error.WriteLine("Unsupported primitive type '{0}' found in geometry '{1}', ignoring.", primitives.PrimitiveType, instance.Name); + continue; + } + + ReadPolygonPrimitives(node, nodeProperties, primitives, instance.Materials.Find(m => m.Symbol == primitives.MaterialSymbol)); + } + } + + private Material ReadMaterial(Dae.Material material) + { + if (material == null || material.Effect == null) + return null; + + Material polygonMaterial; + + if (materialMap.TryGetValue(material, out polygonMaterial)) + return polygonMaterial; + + Dae.EffectSampler diffuseSampler = null; + Dae.EffectSampler transparentSampler = null; + + foreach (var texture in material.Effect.Textures) + { + if (texture.Channel == Dae.EffectTextureChannel.Diffuse) + diffuseSampler = texture.Sampler; + else if (texture.Channel == Dae.EffectTextureChannel.Transparent) + transparentSampler = texture.Sampler; + } + + if (diffuseSampler == null || diffuseSampler.Surface == null || diffuseSampler.Surface.InitFrom == null) + { + // + // this material doesn't have a diffuse texture + // + + return null; + } + + var image = diffuseSampler.Surface.InitFrom; + + if (materialFileMap.TryGetValue(image.FilePath, out polygonMaterial)) + return polygonMaterial; + + polygonMaterial = mesh.Materials.GetMaterial(Path.GetFileNameWithoutExtension(image.FilePath)); + polygonMaterial.ImageFilePath = image.FilePath; + + if (transparentSampler == diffuseSampler) + polygonMaterial.Flags |= GunkFlags.Transparent | GunkFlags.NoOcclusion | GunkFlags.TwoSided; + + materialFileMap.Add(image.FilePath, polygonMaterial); + materialMap.Add(material, polygonMaterial); + + return polygonMaterial; + } + + private void ReadPolygonPrimitives(Dae.Node node, AkiraDaeNodeProperties nodeProperties, Dae.MeshPrimitives primitives, Dae.MaterialInstance materialInstance) + { + Material material = null; + + if (materialInstance != null) + material = ReadMaterial(materialInstance.Target); + + if (material == null) + material = mesh.Materials.NotFound; + + int[] positionIndices = null; + int[] texCoordIndices = null; + int[] normalIndices = null; + Color[] colors = null; + + foreach (var input in primitives.Inputs) + { + switch (input.Semantic) + { + case Dae.Semantic.Position: + positionIndices = ReadInputIndexed(input, positions, uniquePositions, PositionReader); + break; + + case Dae.Semantic.TexCoord: + texCoordIndices = ReadInputIndexed(input, texCoords, Dae.Source.ReadTexCoord); + break; + + case Dae.Semantic.Normal: + normalIndices = ReadInputIndexed(input, normals, Dae.Source.ReadVector3); + break; + + case Dae.Semantic.Color: + colors = ReadInput(input, Dae.Source.ReadColor); + break; + } + } + + if (texCoordIndices == null) + Console.Error.WriteLine("Geometry '{0}' does not contain texture coordinates.", nodeName); + + int startIndex = 0; + int degeneratePolygonCount = 0; + + foreach (int vertexCount in primitives.VertexCounts) + { + var polygonPointIndices = new int[vertexCount]; + Array.Copy(positionIndices, startIndex, polygonPointIndices, 0, vertexCount); + + if (CheckDegenerate(positions, polygonPointIndices)) + { + degeneratePolygonCount++; + startIndex += vertexCount; + continue; + } + + var polygon = new Polygon(mesh, polygonPointIndices) + { + FileName = node.FileName, + ObjectName = node.Name, + Material = material + }; + + if (texCoordIndices != null) + { + polygon.TexCoordIndices = new int[vertexCount]; + Array.Copy(texCoordIndices, startIndex, polygon.TexCoordIndices, 0, vertexCount); + } + else + { + polygon.TexCoordIndices = new int[vertexCount]; + } + + if (normalIndices != null) + { + polygon.NormalIndices = new int[vertexCount]; + Array.Copy(normalIndices, startIndex, polygon.NormalIndices, 0, vertexCount); + } + + if (colors != null) + { + polygon.Colors = new Color[vertexCount]; + Array.Copy(colors, startIndex, polygon.Colors, 0, vertexCount); + } + + startIndex += vertexCount; + + if (nodeProperties != null) + { + polygon.ScriptId = nodeProperties.ScriptId; + polygon.Flags |= nodeProperties.GunkFlags; + } + + if (material == mesh.Materials.Markers.Ghost) + mesh.Ghosts.Add(polygon); + else if (material == mesh.Materials.Markers.DoorFrame) + mesh.Doors.Add(polygon); + else if (material.Name.StartsWith("bnv_grid_", StringComparison.Ordinal)) + mesh.Floors.Add(polygon); + else + mesh.Polygons.Add(polygon); + } + + if (degeneratePolygonCount > 0) + { + Console.Error.WriteLine("Ignoring {0} degenerate polygons", degeneratePolygonCount); + } + } + + private static bool CheckDegenerate(List positions, int[] positionIndices) + { + if (positionIndices.Length < 3) + return true; + + var p0 = positions[positionIndices[0]]; + var p1 = positions[positionIndices[1]]; + + for (int i = 2; i < positionIndices.Length; i++) + { + var p2 = positions[positionIndices[i]]; + + var s0 = p0 - p1; + var s1 = p2 - p1; + + Vector3 c; + Vector3.Cross(ref s0, ref s1, out c); + + if (Math.Abs(c.LengthSquared()) < 0.0001f && Vector3.Dot(s0, s1) > 0.0f) + return true; + + p0 = p1; + p1 = p2; + } + + return false; + } + + private static int[] ReadInputIndexed(Dae.IndexedInput input, List list, Func elementReader) + where T : struct + { + var indices = new int[input.Indices.Count]; + + for (int i = 0; i < input.Indices.Count; i++) + { + var v = elementReader(input.Source, input.Indices[i]); + indices[i] = list.Count; + list.Add(v); + } + + return indices; + } + + private static int[] ReadInputIndexed(Dae.IndexedInput input, List list, Dictionary uniqueList, Func elementReader) + where T : struct + { + var indices = new int[input.Indices.Count]; + + for (int i = 0; i < input.Indices.Count; i++) + { + var v = elementReader(input.Source, input.Indices[i]); + + int index; + + if (!uniqueList.TryGetValue(v, out index)) + { + index = list.Count; + list.Add(v); + uniqueList.Add(v, index); + } + + indices[i] = index; + } + + return indices; + } + + private static T[] ReadInput(Dae.IndexedInput input, Func elementReader) + where T : struct + { + var values = new T[input.Indices.Count]; + + for (int i = 0; i < input.Indices.Count; i++) + values[i] = elementReader(input.Source, input.Indices[i]); + + return values; + } + + private Vector3 PositionReader(Dae.Source source, int index) + { + Vector3 p = Dae.Source.ReadVector3(source, index); + Vector3 r; + Vector3.Transform(ref p, ref nodeTransform, out r); + return r; + } + } +} Index: /OniSplit/Akira/AkiraDaeWriter.cs =================================================================== --- /OniSplit/Akira/AkiraDaeWriter.cs (revision 1114) +++ /OniSplit/Akira/AkiraDaeWriter.cs (revision 1114) @@ -0,0 +1,726 @@ +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 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 polygons = new List(); + private readonly List points = new List(); + private readonly Dictionary uniquePoints = new Dictionary(); + private readonly List texCoords = new List(); + private readonly Dictionary uniqueTexCoords = new Dictionary(); + private readonly List colors = new List(); + private readonly Dictionary uniqueColors = new Dictionary(); + 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 Polygons + { + get + { + return from p in polygons + where p.Source != null + select p.Source; + } + } + + private static int[] Remap(IList values, int[] indices, List list, Dictionary 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(IList values, List list, Dictionary 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(List list, Dictionary 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(); + + 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(); + + 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 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 nameMeshBuilder; + private readonly List meshBuilders; + private readonly Dictionary materials; + private string imagesFolder = "images"; + + public DaeSceneBuilder() + { + scene = new Dae.Scene(); + nameMeshBuilder = new Dictionary(StringComparer.Ordinal); + meshBuilders = new List(); + materials = new Dictionary(); + } + + 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 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(); + + 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(); + 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(); + 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(); + } + } +} Index: /OniSplit/Akira/AkiraDatReader.cs =================================================================== --- /OniSplit/Akira/AkiraDatReader.cs (revision 1114) +++ /OniSplit/Akira/AkiraDatReader.cs (revision 1114) @@ -0,0 +1,515 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Oni.Imaging; +using Oni.Motoko; + +namespace Oni.Akira +{ + internal class AkiraDatReader + { + #region Private data + private InstanceDescriptor akev; + private InstanceDescriptor agdb; + private InstanceDescriptor pnta; + private InstanceDescriptor plea; + private InstanceDescriptor txca; + private InstanceDescriptor agqg; + private InstanceDescriptor agqc; + private InstanceDescriptor agqr; + private InstanceDescriptor txma; + private InstanceDescriptor akva; + private InstanceDescriptor akba; + private InstanceDescriptor idxa1; + private InstanceDescriptor idxa2; + private InstanceDescriptor akbp; + private InstanceDescriptor akaa; + + private PolygonMesh mesh; + private Plane[] planes; + private Polygon[] polygons; + #endregion + + #region private class DatRoom + + private class DatRoom + { + public readonly int BspRootIndex; + public readonly int SideListStart; + public readonly int SideListEnd; + public readonly int ChildIndex; + public readonly int SiblingIndex; + public readonly int XTiles; + public readonly int ZTiles; + public readonly BoundingBox BoundingBox; + public readonly float TileSize; + public readonly int XOrigin; + public readonly int ZOrigin; + public readonly RoomFlags Flags; + public readonly Plane Floor; + public readonly float Height; + public readonly byte[] CompressedGridData; + + public DatRoom(InstanceDescriptor descriptor, BinaryReader reader) + { + BspRootIndex = reader.ReadInt32(); + reader.Skip(4); + SideListStart = reader.ReadInt32(); + SideListEnd = reader.ReadInt32(); + ChildIndex = reader.ReadInt32(); + SiblingIndex = reader.ReadInt32(); + reader.Skip(4); + XTiles = reader.ReadInt32(); + ZTiles = reader.ReadInt32(); + int ofsGridData = reader.ReadInt32(); + int lenGridData = reader.ReadInt32(); + TileSize = reader.ReadSingle(); + BoundingBox = reader.ReadBoundingBox(); + XOrigin = reader.ReadInt16(); + ZOrigin = reader.ReadInt16(); + reader.Skip(16); + Flags = (RoomFlags)reader.ReadInt32(); + Floor = reader.ReadPlane(); + Height = reader.ReadSingle(); + + if (ofsGridData != 0 && lenGridData != 0) + { + using (BinaryReader rawReader = descriptor.GetRawReader(ofsGridData)) + CompressedGridData = rawReader.ReadBytes(lenGridData); + } + } + } + + #endregion + #region private class DatRoomBspNode + + private class DatRoomBspNode + { + public readonly int PlaneIndex; + public readonly int FrontChildIndex; + public readonly int BackChildIndex; + + public DatRoomBspNode(BinaryReader reader) + { + PlaneIndex = reader.ReadInt32(); + BackChildIndex = reader.ReadInt32(); + FrontChildIndex = reader.ReadInt32(); + } + } + + #endregion + #region private class DatRoomSide + + private class DatRoomSide + { + public readonly int SideListStart; + public readonly int SideListEnd; + + public DatRoomSide(BinaryReader reader) + { + reader.Skip(4); + SideListStart = reader.ReadInt32(); + SideListEnd = reader.ReadInt32(); + reader.Skip(16); + } + } + + #endregion + #region private class DatRoomAdjacency + + private class DatRoomAdjacency + { + public readonly int RoomIndex; + public readonly int QuadIndex; + + public DatRoomAdjacency(BinaryReader reader) + { + RoomIndex = reader.ReadInt32(); + QuadIndex = reader.ReadInt32(); + reader.Skip(4); + } + } + + #endregion + + public static PolygonMesh Read(InstanceDescriptor akev) + { + var reader = new AkiraDatReader + { + akev = akev, + mesh = new PolygonMesh(new MaterialLibrary()) + }; + + reader.Read(); + return reader.mesh; + } + + private void Read() + { + using (var reader = akev.OpenRead()) + { + pnta = reader.ReadInstance(); + plea = reader.ReadInstance(); + txca = reader.ReadInstance(); + agqg = reader.ReadInstance(); + agqr = reader.ReadInstance(); + agqc = reader.ReadInstance(); + agdb = reader.ReadInstance(); + txma = reader.ReadInstance(); + akva = reader.ReadInstance(); + akba = reader.ReadInstance(); + idxa1 = reader.ReadInstance(); + idxa2 = reader.ReadInstance(); + akbp = reader.ReadInstance(); + reader.Skip(8); + akaa = reader.ReadInstance(); + } + + ReadGeometry(); + ReadDebugInfo(); + ReadMaterials(); + ReadScriptIndices(); + ReadRooms(); + } + + private void ReadGeometry() + { + int[] planeIndices; + + using (var reader = pnta.OpenRead(52)) + mesh.Points.AddRange(reader.ReadVector3VarArray()); + + using (var reader = txca.OpenRead(20)) + mesh.TexCoords.AddRange(reader.ReadVector2VarArray()); + + using (var reader = plea.OpenRead(20)) + planes = reader.ReadPlaneVarArray(); + + using (var reader = agqc.OpenRead(20)) + { + planeIndices = new int[reader.ReadInt32()]; + + for (int i = 0; i < planeIndices.Length; i++) + { + planeIndices[i] = reader.ReadInt32(); + + // + // Ignore bounding boxes, we don't need them + // + + reader.Skip(24); + } + } + + using (var reader = agqg.OpenRead(20)) + { + polygons = new Polygon[reader.ReadInt32()]; + + for (int i = 0; i < polygons.Length; i++) + { + var pointIndices = reader.ReadInt32Array(4); + var texCoordIndices = reader.ReadInt32Array(4); + var colors = reader.ReadColorArray(4); + var flags = (GunkFlags)reader.ReadInt32(); + int objectId = reader.ReadInt32(); + + if ((flags & GunkFlags.Triangle) != 0) + { + Array.Resize(ref pointIndices, 3); + Array.Resize(ref texCoordIndices, 3); + Array.Resize(ref colors, 3); + + flags &= ~GunkFlags.Triangle; + } + + var polygon = new Polygon(mesh, pointIndices, PlaneFromIndex(planeIndices[i])) + { + Flags = flags & ~GunkFlags.Transparent, + TexCoordIndices = texCoordIndices, + Colors = colors + }; + + if (objectId == -1) + { + polygon.ObjectType = -1; + polygon.ObjectId = -1; + } + else + { + polygon.ObjectType = (objectId >> 24) & 0xff; + polygon.ObjectId = objectId & 0xffffff; + } + + polygons[i] = polygon; + } + } + + foreach (var polygon in polygons) + { + if ((polygon.Flags & (GunkFlags.Ghost | GunkFlags.StairsUp | GunkFlags.StairsDown)) != 0) + mesh.Ghosts.Add(polygon); + else + mesh.Polygons.Add(polygon); + } + } + + private Plane PlaneFromIndex(int index) + { + var plane = planes[index & int.MaxValue]; + + if (index < 0) + { + plane.Normal = -plane.Normal; + plane.D = -plane.D; + } + + return plane; + } + + private void ReadMaterials() + { + // + // Read material list from TXMA + // + + Material[] materials; + + using (var reader = txma.OpenRead(20)) + { + materials = new Material[reader.ReadInt32()]; + + for (int i = 0; i < materials.Length; i++) + { + var texture = reader.ReadInstance(); + + if (texture == null) + continue; + + var material = mesh.Materials.GetMaterial(Utils.CleanupTextureName(texture.Name)); + material.Image = TextureDatReader.Read(texture).Surfaces[0]; + + if (material.Image.HasAlpha) + material.Flags |= GunkFlags.Transparent; + + materials[i] = material; + } + } + + // + // Assign materials to polygons based on AGQR + // + + using (var reader = agqr.OpenRead(20)) + { + int count = reader.ReadInt32(); + + for (int i = 0; i < count; i++) + polygons[i].Material = materials[reader.ReadInt32() & 0xffff]; + } + + // + // Assign special materials: danger, stairs etc. + // + + foreach (var polygon in polygons) + { + var marker = mesh.Materials.Markers.GetMarker(polygon); + + if (marker != null) + polygon.Material = marker; + } + } + + private void ReadScriptIndices() + { + if (idxa1 == null || idxa2 == null) + return; + + int[] scriptQuadIndices; + int[] scriptIds; + + using (var reader = idxa1.OpenRead(20)) + scriptQuadIndices = reader.ReadInt32VarArray(); + + using (var reader = idxa2.OpenRead(20)) + scriptIds = reader.ReadInt32VarArray(); + + for (int i = 0; i < scriptQuadIndices.Length; i++) + polygons[scriptQuadIndices[i]].ScriptId = scriptIds[i]; + } + + private void ReadDebugInfo() + { + if (agdb == null) + { + var debugFileName = "AGDB" + akev.Name + ".oni"; + var debugFilePath = Path.Combine(Path.GetDirectoryName(akev.File.FilePath), debugFileName); + + if (!File.Exists(debugFilePath)) + return; + + Console.WriteLine(debugFilePath); + + var debugFile = akev.File.FileManager.OpenFile(debugFilePath); + + if (debugFile == null) + return; + + agdb = debugFile.Descriptors[0]; + } + + if (agdb == null || agdb.Template.Tag != TemplateTag.AGDB) + return; + + using (var reader = agdb.OpenRead(20)) + { + int count = reader.ReadInt32(); + + var fileNames = new Dictionary(); + var objectNames = new Dictionary(); + + for (int i = 0; i < count; i++) + { + int objectNameOffset = reader.ReadInt32(); + string objectName; + + if (!objectNames.TryGetValue(objectNameOffset, out objectName)) + { + using (var rawReader = agdb.GetRawReader(objectNameOffset)) + objectName = rawReader.ReadString(256); + + objectName = objectName.Replace('.', '_'); + objectNames.Add(objectNameOffset, objectName); + } + + int fileNameOffset = reader.ReadInt32(); + string fileName; + + if (!fileNames.TryGetValue(fileNameOffset, out fileName)) + { + using (var rawReader = agdb.GetRawReader(fileNameOffset)) + fileName = rawReader.ReadString(256); + + fileName = Path.GetFileNameWithoutExtension(fileName); + fileNames.Add(fileNameOffset, fileName); + } + + if (!string.IsNullOrEmpty(objectName)) + mesh.HasDebugInfo = true; + + polygons[i].ObjectName = objectName; + polygons[i].FileName = fileName; + } + } + } + + private void ReadRooms() + { + DatRoomBspNode[] bspTrees; + DatRoomSide[] roomSides; + DatRoomAdjacency[] roomAdjacencies; + DatRoom[] roomsData; + + using (var reader = akbp.OpenRead(22)) + { + bspTrees = new DatRoomBspNode[reader.ReadUInt16()]; + + for (int i = 0; i < bspTrees.Length; i++) + bspTrees[i] = new DatRoomBspNode(reader); + } + + using (var reader = akba.OpenRead(20)) + { + roomSides = new DatRoomSide[reader.ReadInt32()]; + + for (int i = 0; i < roomSides.Length; i++) + roomSides[i] = new DatRoomSide(reader); + } + + using (var reader = akaa.OpenRead(20)) + { + roomAdjacencies = new DatRoomAdjacency[reader.ReadInt32()]; + + for (int i = 0; i < roomAdjacencies.Length; i++) + roomAdjacencies[i] = new DatRoomAdjacency(reader); + } + + using (var reader = akva.OpenRead(20)) + { + roomsData = new DatRoom[reader.ReadInt32()]; + + for (int i = 0; i < roomsData.Length; i++) + roomsData[i] = new DatRoom(akva, reader); + } + + var rooms = new Room[roomsData.Length]; + + for (int i = 0; i < roomsData.Length; i++) + { + var data = roomsData[i]; + + var room = new Room + { + BspTree = BspNodeDataToBspNode(bspTrees, data.BspRootIndex), + BoundingBox = data.BoundingBox + }; + + if ((data.Flags & RoomFlags.Stairs) != 0) + { + room.FloorPlane = data.Floor; + room.Height = data.Height; + } + else + { + room.FloorPlane = new Plane(Vector3.Up, -data.BoundingBox.Min.Y); + room.Height = data.BoundingBox.Max.Y - data.BoundingBox.Min.Y; + } + + room.Grid = RoomGrid.FromCompressedData(data.XTiles, data.ZTiles, data.CompressedGridData); + rooms[i] = room; + } + + for (int i = 0; i < roomsData.Length; i++) + { + var data = roomsData[i]; + var room = rooms[i]; + + //if (data.SiblingIndex != -1) + // room.Sibling = rooms[data.SiblingIndex]; + + //if (data.ChildIndex != -1) + // room.Child = rooms[data.ChildIndex]; + + for (int j = data.SideListStart; j < data.SideListEnd; j++) + { + var sideData = roomSides[j]; + + for (int k = sideData.SideListStart; k < sideData.SideListEnd; k++) + { + var adjData = roomAdjacencies[k]; + var adjacentRoom = rooms[adjData.RoomIndex]; + var ghost = polygons[adjData.QuadIndex]; + + room.Ajacencies.Add(new RoomAdjacency(adjacentRoom, ghost)); + } + } + } + + mesh.Rooms.AddRange(rooms); + } + + private RoomBspNode BspNodeDataToBspNode(DatRoomBspNode[] data, int index) + { + var nodeData = data[index]; + RoomBspNode front = null, back = null; + + if (nodeData.BackChildIndex != -1) + back = BspNodeDataToBspNode(data, nodeData.BackChildIndex); + + if (nodeData.FrontChildIndex != -1) + front = BspNodeDataToBspNode(data, nodeData.FrontChildIndex); + + return new RoomBspNode(PlaneFromIndex(nodeData.PlaneIndex), back, front); + } + } +} Index: /OniSplit/Akira/AkiraDatWriter.cs =================================================================== --- /OniSplit/Akira/AkiraDatWriter.cs (revision 1114) +++ /OniSplit/Akira/AkiraDatWriter.cs (revision 1114) @@ -0,0 +1,1070 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class AkiraDatWriter + { + #region Private data + private Importer importer; + private string name; + private bool debug; + private PolygonMesh source; + + private List polygons = new List(); + private Dictionary polygonMap = new Dictionary(); + + private UniqueList points = new UniqueList(); + private UniqueList texCoords = new UniqueList(); + private UniqueList materials = new UniqueList(); + private UniqueList planes = new UniqueList(); + + private List alphaBspNodes = new List(); + + private List rooms = new List(); + private Dictionary roomMap = new Dictionary(); + private List roomBspNodes = new List(); + private List roomSides = new List(); + private List roomAdjacencies = new List(); + + private DatOctree octree; + #endregion + + #region private class UniqueList + + private class UniqueList : ICollection + { + private readonly List list = new List(); + private readonly Dictionary indices = new Dictionary(); + + public int Add(T t) + { + int index; + + if (!indices.TryGetValue(t, out index)) + { + index = list.Count; + indices.Add(t, index); + list.Add(t); + } + + return index; + } + + #region ICollection Members + + void ICollection.Add(T item) => Add(item); + + public int Count => list.Count; + + void ICollection.Clear() + { + list.Clear(); + indices.Clear(); + } + + bool ICollection.Contains(T item) => indices.ContainsKey(item); + + void ICollection.CopyTo(T[] array, int arrayIndex) + { + list.CopyTo(array, arrayIndex); + } + + bool ICollection.IsReadOnly => false; + + bool ICollection.Remove(T item) + { + throw new NotImplementedException(); + } + + IEnumerator IEnumerable.GetEnumerator() => list.GetEnumerator(); + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => list.GetEnumerator(); + + #endregion + } + + #endregion + + #region private class DatObject + + private class DatObject + { + private readonly T source; + + public DatObject(T source) + { + this.source = source; + } + + public T Source => source; + } + + #endregion + #region private class DatPolygon + + private class DatPolygon : DatObject + { + private static readonly Color defaultColor = new Color(207, 207, 207, 255); + private static readonly Color[] defaultColors = new[] { defaultColor, defaultColor, defaultColor, defaultColor }; + private GunkFlags flags; + private readonly int index; + public readonly int[] PointIndices = new int[4]; + public readonly int[] TexCoordIndices = new int[4]; + public readonly Color[] Colors = new Color[4]; + private readonly int objectId; + private readonly int scriptId; + private int materialIndex; + private int planeIndex; + + public DatPolygon(Polygon source, int index, UniqueList points, UniqueList texCoords) + : base(source) + { + this.index = index; + this.scriptId = source.ScriptId; + + objectId = source.ObjectType << 24 | (source.ObjectId & 0xffffff); + flags = source.Flags; + + if (source.VertexCount == 3) + { + flags |= GunkFlags.Triangle; + + Array.Copy(source.PointIndices, PointIndices, 3); + PointIndices[3] = PointIndices[2]; + + Array.Copy(source.TexCoordIndices, TexCoordIndices, 3); + TexCoordIndices[3] = TexCoordIndices[2]; + + if (source.Colors == null) + { + Colors = defaultColors; + } + else + { + Array.Copy(source.Colors, Colors, 3); + Colors[3] = Colors[2]; + } + } + else + { + Array.Copy(source.PointIndices, PointIndices, 4); + Array.Copy(source.TexCoordIndices, TexCoordIndices, 4); + + if (source.Colors != null) + Colors = source.Colors; + else + Colors = defaultColors; + } + + for (int i = 0; i < 4; i++) + { + PointIndices[i] = points.Add(source.Mesh.Points[PointIndices[i]]); + TexCoordIndices[i] = texCoords.Add(source.Mesh.TexCoords[TexCoordIndices[i]]); + } + } + + public int Index => index; + public int ObjectId => objectId; + public int ScriptId => scriptId; + + public GunkFlags Flags + { + get { return flags; } + set { flags = value; } + } + + public int MaterialIndex + { + get { return materialIndex; } + set { materialIndex = value; } + } + + public int PlaneIndex + { + get { return planeIndex; } + set { planeIndex = value; } + } + } + + #endregion + #region private class DatBspNode + + private class DatBspNode : DatObject + where T : BspNode + { + public int PlaneIndex; + public int FrontChildIndex = -1; + public int BackChildIndex = -1; + + public DatBspNode(T source) + : base(source) + { + } + } + + #endregion + #region private class DatAlphaBspNode + + private class DatAlphaBspNode : DatBspNode + { + public readonly int PolygonIndex; + + public DatAlphaBspNode(AlphaBspNode source, int polygonIndex) + : base(source) + { + PolygonIndex = polygonIndex; + } + } + + #endregion + #region private class DatRoom + + private class DatRoom : DatObject + { + private readonly int index; + private readonly RoomFlags flags; + + public int BspTreeIndex; + public int SideListStart; + public int SideListEnd; + public int ChildIndex = -1; + public int SiblingIndex = -1; + public byte[] CompressedGridData; + public byte[] DebugData; + + public DatRoom(Room source, int index) + : base(source) + { + this.index = index; + this.flags = RoomFlags.Room; + + if (source.FloorPlane.Normal.Y < 0.999f) + this.flags |= RoomFlags.Stairs; + } + + public int Index => index; + public int Flags => (int)flags; + } + + #endregion + #region private class DatRoomBspNode + + private class DatRoomBspNode : DatBspNode + { + public DatRoomBspNode(RoomBspNode source) + : base(source) + { + } + } + + #endregion + #region private class DatRoomSide + + private class DatRoomSide + { + public int AdjacencyListStart; + public int AdjacencyListEnd; + } + + #endregion + #region private class DatRoomAdjacency + + private class DatRoomAdjacency : DatObject + { + public DatRoomAdjacency(RoomAdjacency source) + : base(source) + { + } + + public int AdjacentRoomIndex; + public int GhostIndex; + } + + #endregion + #region private class DatOctree + + private class DatOctree + { + public int[] Nodes; + public int[] QuadTrees; + public int[] Adjacency; + public DatOctreeBoundingBox[] BoundingBoxes; + public DatOctreePolygonRange[] PolygonLists; + public DatOctreeBnvRange[] BnvLists; + public int[] PolygonIndex; + public int[] BnvIndex; + } + + #endregion + #region private struct DatOctreeBoundingBox + + private struct DatOctreeBoundingBox + { + private readonly uint value; + + public DatOctreeBoundingBox(BoundingBox bbox) + { + int size = (int)(Math.Log(bbox.Max.X - bbox.Min.X, 2)) - 4; + int maxX = (int)(bbox.Max.X + 4080.0f); + int maxY = (int)(bbox.Max.Y + 4080.0f); + int maxZ = (int)(bbox.Max.Z + 4080.0f); + + value = (uint)((maxX << 14) | (maxY << 5) | (maxZ >> 4) | (size << 27)); + } + + public uint PackedValue => value; + } + + #endregion + #region private struct DatOctreeBnvRange + + private struct DatOctreeBnvRange + { + private const int indexBitOffset = 8; + private const int lengthBitMask = 255; + private readonly uint value; + + public DatOctreeBnvRange(int start, int length) + { + ValidateRange(start, length); + value = (uint)((start << indexBitOffset) | (length & lengthBitMask)); + } + + private static void ValidateRange(int start, int length) + { + if (start > 16777215) + throw new ArgumentException(string.Format("Invalid bnv list start index {0}", start), "start"); + + if (length > 255) + throw new ArgumentException(string.Format("Invalid bnv list length {0}", length), "length"); + } + + public uint PackedValue => value; + } + + #endregion + #region private struct DatOctreePolygonRange + + private struct DatOctreePolygonRange + { + private const int indexBitOffset = 12; + private const int lengthBitMask = 4095; + private readonly uint value; + + public DatOctreePolygonRange(int start, int length) + { + //ValidateRange(start, length); + + if (start > 1048575) + { + start = 1048575; + length = 0; + } + + value = (uint)((start << indexBitOffset) | (length & lengthBitMask)); + } + + private static void ValidateRange(int start, int length) + { + if (start > 1048575) + throw new ArgumentException(string.Format("Invalid quad list start index {0}", start), "start"); + + if (length > 4095) + throw new ArgumentException(string.Format("Invalid quad list length {0}", length), "length"); + } + + public uint PackedValue => value; + } + + #endregion + + public static void Write(PolygonMesh mesh, Importer importer, string name, bool debug) + { + var writer = new AkiraDatWriter { + name = name, + importer = importer, + source = mesh, + debug = debug + }; + + writer.Write(); + } + + private void Write() + { + Console.Error.WriteLine("Environment bounding box is {0}", source.GetBoundingBox()); + + RoomBuilder.BuildRooms(source); + + ConvertPolygons(source.Polygons); + ConvertPolygons(source.Doors); + ConvertPolygons(source.Ghosts); + ConvertAlphaBspTree(AlphaBspBuilder.Build(source, debug)); + ConvertRooms(); + ConvertOctree(); + + WriteAKEV(); + + //foreach (Material material in materials) + //{ + // if (File.Exists(material.ImageFilePath)) + // importer.AddDependency(material.ImageFilePath, TemplateTag.TXMP); + //} + } + + private void ConvertPolygons(List sourcePolygons) + { + foreach (var polygon in sourcePolygons) + { + if (polygon.VertexCount > 4) + { + Console.Error.WriteLine("Geometry '{0}' has a {1}-gon, ignoring.", polygon.ObjectName, polygon.VertexCount); + continue; + } + + if (polygon.TexCoordIndices == null) + { + Console.Error.WriteLine("Geometry '{0}' does not contain texture coordinates, ignoring.", polygon.ObjectName); + continue; + } + + var datPolygon = new DatPolygon(polygon, polygons.Count, points, texCoords) { + PlaneIndex = planes.Add(polygon.Plane), + MaterialIndex = materials.Add(polygon.Material) + }; + + polygons.Add(datPolygon); + polygonMap.Add(polygon, datPolygon); + } + + //var noneMaterial = source.Materials.GetMaterial("NONE"); + //int noneMaterialIndex = materials.Add(noneMaterial); + + //foreach (var polygon in polygons) + //{ + // var material = polygon.Source.Material; + + //if (material.IsMarker) + //{ + // polygon.MaterialIndex = noneMaterialIndex; + + // if (material != source.Materials.Markers.Blackness && (material.Flags & GunkFlags.Invisible) == 0) + // polygon.Flags |= GunkFlags.Transparent; + //} + //else + //{ + // polygon.MaterialIndex = materials.Add(material); + //} + //} + } + + private int ConvertAlphaBspTree(AlphaBspNode source) + { + if (source == null) + return -1; + + int index = alphaBspNodes.Count; + + var node = new DatAlphaBspNode(source, polygonMap[source.Polygon].Index) { + PlaneIndex = planes.Add(source.Plane) + }; + + alphaBspNodes.Add(node); + + if (source.FrontChild != null) + node.FrontChildIndex = ConvertAlphaBspTree((AlphaBspNode)source.FrontChild); + + if (source.BackChild != null) + node.BackChildIndex = ConvertAlphaBspTree((AlphaBspNode)source.BackChild); + + return index; + } + + private void ConvertRooms() + { + foreach (var room in source.Rooms) + { + var datRoom = new DatRoom(room, rooms.Count) { + BspTreeIndex = ConvertRoomBspTree(room.BspTree), + CompressedGridData = room.Grid.Compress(), + DebugData = room.Grid.DebugData, + SideListStart = roomSides.Count + }; + + if (room.Ajacencies.Count > 0) + { + var datSide = new DatRoomSide { + AdjacencyListStart = roomAdjacencies.Count + }; + + foreach (var adjacency in room.Ajacencies) + { + roomAdjacencies.Add(new DatRoomAdjacency(adjacency) { + AdjacentRoomIndex = source.Rooms.IndexOf(adjacency.AdjacentRoom), + GhostIndex = polygonMap[adjacency.Ghost].Index + }); + } + + datSide.AdjacencyListEnd = roomAdjacencies.Count; + roomSides.Add(datSide); + } + + datRoom.SideListEnd = roomSides.Count; + + rooms.Add(datRoom); + roomMap.Add(room, datRoom); + } + } + + private int ConvertRoomBspTree(RoomBspNode node) + { + int index = roomBspNodes.Count; + + var datNode = new DatRoomBspNode(node) { + PlaneIndex = planes.Add(node.Plane) + }; + + roomBspNodes.Add(datNode); + + if (node.FrontChild != null) + datNode.FrontChildIndex = ConvertRoomBspTree(node.FrontChild); + + if (node.BackChild != null) + datNode.BackChildIndex = ConvertRoomBspTree(node.BackChild); + + return index; + } + + private void ConvertOctree() + { + Console.Error.WriteLine("Building octtree for {0} polygons...", source.Polygons.Count); + + var root = OctreeBuilder.Build(source, debug); + + var nodeList = new List(); + var leafList = new List(); + int quadListLength = 0; + int roomListLength = 0; + + // + // Assign indices to nodes/leafs and compute the length of the quad and room indexes. + // + + root.DfsTraversal(node => { + if (node.IsLeaf) + { + node.Index = leafList.Count; + leafList.Add(node); + quadListLength += node.Polygons.Count; + roomListLength += node.Rooms.Count; + } + else + { + node.Index = nodeList.Count; + nodeList.Add(node); + } + }); + + // + // Create the octtree data structure that will be written to the file. + // + + octree = new DatOctree { + Nodes = new int[nodeList.Count * OctreeNode.ChildCount], + Adjacency = new int[leafList.Count * OctreeNode.FaceCount], + BoundingBoxes = new DatOctreeBoundingBox[leafList.Count], + PolygonIndex = new int[quadListLength], + PolygonLists = new DatOctreePolygonRange[leafList.Count], + BnvLists = new DatOctreeBnvRange[leafList.Count], + BnvIndex = new int[roomListLength] + }; + + Console.WriteLine("Octtree: {0} interior nodes, {1} leafs", nodeList.Count, leafList.Count); + + // + // Populate the node array. + // The octree builder stores child nodes in a different order than Oni (by mistake) + // + + var interiorNodeIndexRemap = new int[] { 0, 4, 2, 6, 1, 5, 3, 7 }; + var datOcttree = octree; + + foreach (var node in nodeList) + { + int i = node.Index * OctreeNode.ChildCount; + + for (int j = 0; j < OctreeNode.ChildCount; j++) + { + var child = node.Children[j]; + int k = interiorNodeIndexRemap[j]; + + if (child.IsLeaf) + datOcttree.Nodes[i + k] = child.Index | int.MinValue; + else + datOcttree.Nodes[i + k] = child.Index; + } + } + + // + // Generate the data needed by the leafs: bounding box, quad range and room range. + // + + int quadListIndex = 0; + int bnvListIndex = 0; + + foreach (var leaf in leafList) + { + datOcttree.BoundingBoxes[leaf.Index] = new DatOctreeBoundingBox(leaf.BoundingBox); + + if (leaf.Polygons.Count > 0) + { + datOcttree.PolygonLists[leaf.Index] = new DatOctreePolygonRange(quadListIndex, leaf.Polygons.Count); + + foreach (var polygon in leaf.Polygons) + datOcttree.PolygonIndex[quadListIndex++] = polygonMap[polygon].Index; + } + + if (leaf.Rooms.Count > 0) + { + datOcttree.BnvLists[leaf.Index] = new DatOctreeBnvRange(bnvListIndex, leaf.Rooms.Count); + + foreach (var room in leaf.Rooms) + datOcttree.BnvIndex[bnvListIndex++] = roomMap[room].Index; + } + } + + // + // Generate the quad trees. Note that the octtree builder doesn't build quad trees because + // they're only needed when writing the octtree to the file. Currently OniSplit doesn't use + // the octtree for raycasting. + // + + var quadTrees = new List(); + + foreach (var leaf in leafList) + { + leaf.RefineAdjacency(); + + foreach (var face in OctreeNode.Face.All) + { + var adjacentLeaf = leaf.Adjacency[face.Index]; + int index = leaf.Index * OctreeNode.FaceCount + face.Index; + + if (adjacentLeaf == null) + { + // + // There's no adjacent node or leaf, this should only happen + // on the edges of the octtree. + // + + datOcttree.Adjacency[index] = -1; + } + else if (adjacentLeaf.IsLeaf) + { + // + // The adjacent node is a leaf, there's no need for a quad tree. + // + + datOcttree.Adjacency[index] = adjacentLeaf.Index | int.MinValue; + } + else + { + // + // The adjacent node has children, a quad tree needs to be built. + // + + int quadTreeBaseIndex = quadTrees.Count / 4; + datOcttree.Adjacency[index] = quadTreeBaseIndex; + + var quadTreeRoot = leaf.BuildFaceQuadTree(face); + + foreach (var node in quadTreeRoot.GetDfsList()) + { + for (int i = 0; i < 4; i++) + { + if (node.Nodes[i] != null) + quadTrees.Add(quadTreeBaseIndex + node.Nodes[i].Index); + else + quadTrees.Add(node.Leafs[i].Index | int.MinValue); + } + } + } + } + } + + datOcttree.QuadTrees = quadTrees.ToArray(); + } + + private void WriteAKEV() + { + var akev = importer.CreateInstance(TemplateTag.AKEV, name); + var pnta = importer.CreateInstance(TemplateTag.PNTA); + var plea = importer.CreateInstance(TemplateTag.PLEA); + var txca = importer.CreateInstance(TemplateTag.TXCA); + var agqg = importer.CreateInstance(TemplateTag.AGQG); + var agqr = importer.CreateInstance(TemplateTag.AGQR); + var agqc = importer.CreateInstance(TemplateTag.AGQC); + var agdb = importer.CreateInstance(TemplateTag.AGDB); + var txma = importer.CreateInstance(TemplateTag.TXMA); + var akva = importer.CreateInstance(TemplateTag.AKVA); + var akba = importer.CreateInstance(TemplateTag.AKBA); + var idxa1 = importer.CreateInstance(TemplateTag.IDXA); + var idxa2 = importer.CreateInstance(TemplateTag.IDXA); + var akbp = importer.CreateInstance(TemplateTag.AKBP); + var abna = importer.CreateInstance(TemplateTag.ABNA); + var akot = importer.CreateInstance(TemplateTag.AKOT); + var akaa = importer.CreateInstance(TemplateTag.AKAA); + var akda = importer.CreateInstance(TemplateTag.AKDA); + + using (var writer = akev.OpenWrite()) + { + writer.Write(pnta); + writer.Write(plea); + writer.Write(txca); + writer.Write(agqg); + writer.Write(agqr); + writer.Write(agqc); + writer.Write(agdb); + writer.Write(txma); + writer.Write(akva); + writer.Write(akba); + writer.Write(idxa1); + writer.Write(idxa2); + writer.Write(akbp); + writer.Write(abna); + writer.Write(akot); + writer.Write(akaa); + writer.Write(akda); + writer.Write(source.GetBoundingBox()); + writer.Skip(24); + writer.Write(12.0f); + } + + pnta.WritePoints(points); + plea.WritePlanes(planes); + txca.WriteTexCoords(texCoords); + WriteAGQG(agqg); + WriteAGQR(agqr); + WriteAGQC(agqc); + WriteTXMA(txma); + WriteAKVA(akva); + WriteAKBA(akba); + WriteAKBP(akbp); + WriteABNA(abna); + WriteAKOT(akot); + WriteAKAA(akaa); + WriteAKDA(akda); + WriteScriptIds(idxa1, idxa2); + WriteAGDB(agdb); + } + + private void WriteAGQG(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(polygons.Count); + + foreach (var polygon in polygons) + { + writer.Write(polygon.PointIndices); + writer.Write(polygon.TexCoordIndices); + writer.Write(polygon.Colors); + writer.Write((uint)polygon.Flags); + writer.Write(polygon.ObjectId); + } + } + } + + private void WriteAGQC(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(polygons.Count); + + foreach (var polygon in polygons) + { + writer.Write(polygon.PlaneIndex); + writer.Write(polygon.Source.BoundingBox); + } + } + } + + private void WriteAGQR(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(polygons.Count); + + foreach (var polygon in polygons) + { + writer.Write(polygon.MaterialIndex); + } + } + } + + private void WriteTXMA(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(materials.Count); + + foreach (var material in materials) + { + writer.Write(importer.CreateInstance(TemplateTag.TXMP, material.Name)); + } + } + } + + private void WriteABNA(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(alphaBspNodes.Count); + + foreach (var node in alphaBspNodes) + { + writer.Write(node.PolygonIndex); + writer.Write(node.PlaneIndex); + writer.Write(node.FrontChildIndex); + writer.Write(node.BackChildIndex); + } + } + } + + private void WriteAKVA(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(rooms.Count); + + foreach (var room in rooms) + { + writer.Write(room.BspTreeIndex); + writer.Write(room.Index); + writer.Write(room.SideListStart); + writer.Write(room.SideListEnd); + writer.Write(room.ChildIndex); + writer.Write(room.SiblingIndex); + writer.Skip(4); + writer.Write(room.Source.Grid.XTiles); + writer.Write(room.Source.Grid.ZTiles); + writer.Write(importer.WriteRawPart(room.CompressedGridData)); + writer.Write(room.CompressedGridData.Length); + writer.Write(room.Source.Grid.TileSize); + writer.Write(room.Source.BoundingBox); + writer.WriteInt16(room.Source.Grid.XOrigin); + writer.WriteInt16(room.Source.Grid.ZOrigin); + writer.Write(room.Index); + writer.Skip(4); + + if (room.DebugData != null) + { + writer.Write(room.DebugData.Length); + writer.Write(importer.WriteRawPart(room.DebugData)); + } + else + { + writer.Write(0); + writer.Write(0); + } + + writer.Write(room.Flags); + writer.Write(room.Source.FloorPlane); + writer.Write(room.Source.Height); + } + } + } + + private void WriteAKBA(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(roomSides.Count); + + foreach (var side in roomSides) + { + writer.Write(0); + writer.Write(side.AdjacencyListStart); + writer.Write(side.AdjacencyListEnd); + writer.Skip(16); + } + } + } + + private void WriteAKBP(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(22)) + { + writer.WriteUInt16(roomBspNodes.Count); + + foreach (var node in roomBspNodes) + { + writer.Write(node.PlaneIndex); + writer.Write(node.BackChildIndex); + writer.Write(node.FrontChildIndex); + } + } + } + + private void WriteAKAA(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(roomAdjacencies.Count); + + foreach (var adjacency in roomAdjacencies) + { + writer.Write(adjacency.AdjacentRoomIndex); + writer.Write(adjacency.GhostIndex); + writer.Write(0); + } + } + } + + private void WriteAKDA(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(0); + } + } + + private void WriteAKOT(ImporterDescriptor akot) + { + var otit = importer.CreateInstance(TemplateTag.OTIT); + var otlf = importer.CreateInstance(TemplateTag.OTLF); + var qtna = importer.CreateInstance(TemplateTag.QTNA); + var idxa1 = importer.CreateInstance(TemplateTag.IDXA); + var idxa2 = importer.CreateInstance(TemplateTag.IDXA); + + using (var writer = akot.OpenWrite()) + { + writer.Write(otit); + writer.Write(otlf); + writer.Write(qtna); + writer.Write(idxa1); + writer.Write(idxa2); + } + + WriteOTIT(otit); + WriteOTLF(otlf); + WriteQTNA(qtna); + + idxa1.WriteIndices(octree.PolygonIndex); + idxa2.WriteIndices(octree.BnvIndex); + } + + private void WriteOTIT(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(octree.Nodes.Length / OctreeNode.ChildCount); + writer.Write(octree.Nodes); + } + } + + private void WriteOTLF(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(octree.BoundingBoxes.Length); + + for (int i = 0; i < octree.BoundingBoxes.Length; i++) + { + writer.Write(octree.PolygonLists[i].PackedValue); + writer.Write(octree.Adjacency, i * OctreeNode.FaceCount, OctreeNode.FaceCount); + writer.Write(octree.BoundingBoxes[i].PackedValue); + writer.Write(octree.BnvLists[i].PackedValue); + } + } + } + + private void WriteQTNA(ImporterDescriptor descriptor) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(octree.QuadTrees.Length / 4); + writer.Write(octree.QuadTrees); + } + } + + private void WriteScriptIds(ImporterDescriptor idxa1, ImporterDescriptor idxa2) + { + var scriptIdMap = new List>(256); + + foreach (var polygon in polygons) + { + if (polygon.ScriptId != 0) + scriptIdMap.Add(new KeyValuePair(polygon.ScriptId, polygon.Index)); + } + + scriptIdMap.Sort((x, y) => x.Key.CompareTo(y.Key)); + + var scriptIds = new int[scriptIdMap.Count]; + var polygonIndices = new int[scriptIdMap.Count]; + + for (int i = 0; i < scriptIdMap.Count; i++) + { + scriptIds[i] = scriptIdMap[i].Key; + polygonIndices[i] = scriptIdMap[i].Value; + } + + idxa1.WriteIndices(polygonIndices); + idxa2.WriteIndices(scriptIds); + } + + private void WriteAGDB(ImporterDescriptor descriptor) + { + if (!debug) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(0); + } + + return; + } + + var objectNames = new Dictionary(polygons.Count, StringComparer.Ordinal); + var fileNames = new Dictionary(polygons.Count, StringComparer.Ordinal); + + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(polygons.Count); + + foreach (var polygon in polygons) + { + var objectName = polygon.Source.ObjectName; + var fileName = polygon.Source.FileName; + + if (string.IsNullOrEmpty(objectName)) + objectName = "(none)"; + + if (string.IsNullOrEmpty(fileName)) + fileName = "(none)"; + + int objectOffset; + int fileOffset; + + if (!objectNames.TryGetValue(objectName, out objectOffset)) + { + objectOffset = importer.WriteRawPart(objectName); + objectNames.Add(objectName, objectOffset); + } + + if (!fileNames.TryGetValue(fileName, out fileOffset)) + { + fileOffset = importer.WriteRawPart(fileName); + fileNames.Add(fileName, fileOffset); + } + + writer.Write(objectOffset); + writer.Write(fileOffset); + } + } + } + } +} Index: /OniSplit/Akira/AkiraImporter.cs =================================================================== --- /OniSplit/Akira/AkiraImporter.cs (revision 1114) +++ /OniSplit/Akira/AkiraImporter.cs (revision 1114) @@ -0,0 +1,64 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class AkiraImporter : Importer + { + private bool debug; + //private string defaultTexture = "NONE"; + //private bool importLights; + //private bool noLight; + //private bool noTextures; + + public AkiraImporter(string[] args) + { + foreach (string arg in args) + { + if (arg == "-debug") + { + debug = true; + } + //if (arg.StartsWith("-texdefault:", StringComparison.Ordinal)) + //{ + // int i = arg.IndexOf(':'); + // defaultTexture = arg.Substring(i + 1); + //} + //else if (arg.StartsWith("-lights", StringComparison.Ordinal)) + //{ + // importLights = true; + //} + //else if (arg == "-env-notxmp") + //{ + // noTextures = true; + //} + //else if (arg.StartsWith("-nolight", StringComparison.Ordinal)) + //{ + // noLight = true; + //} + } + } + + public override void Import(string filePath, string outputDirPath) + { + Import(new[] { filePath }, outputDirPath); + } + + public void Import(IList files, string outputDirPath) + { + Import(files, outputDirPath, Path.GetFileNameWithoutExtension(files[0])); + } + + public void Import(IList files, string outputDirPath, string name) + { + PolygonMesh mesh = AkiraDaeReader.Read(files); + + BeginImport(); + AkiraDatWriter.Write(mesh, this, name, debug); + Write(outputDirPath); + } + } +} Index: /OniSplit/Akira/AlphaBspBuilder.cs =================================================================== --- /OniSplit/Akira/AlphaBspBuilder.cs (revision 1114) +++ /OniSplit/Akira/AlphaBspBuilder.cs (revision 1114) @@ -0,0 +1,86 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Akira +{ + internal class AlphaBspBuilder + { + private PolygonMesh mesh; + private bool debug; + + public static AlphaBspNode Build(PolygonMesh mesh, bool debug) + { + var builder = new AlphaBspBuilder + { + mesh = mesh, + debug = debug + }; + + return builder.Build(); + } + + private AlphaBspNode Build() + { + var transparent = new List(1024); + + transparent.AddRange(mesh.Polygons.Where(p => p.IsTransparent)); + + if (debug) + transparent.AddRange(mesh.Ghosts.Where(p => p.IsTransparent)); + + Console.Error.WriteLine("Building bsp tree for {0} transparent polygons...", transparent.Count); + return Build(transparent); + } + + private AlphaBspNode Build(List polygons) + { + if (polygons.Count == 0) + return null; + + var separator = polygons[0].Plane; + AlphaBspNode frontNode = null, backNode = null; + + if (polygons.Count > 1) + { + var front = new List(polygons.Count); + var back = new List(polygons.Count); + + for (int i = 1; i < polygons.Count; i++) + { + var polygon = polygons[i]; + var plane = polygon.Plane; + + bool isFront = false; + bool isBack = false; + + if (Math.Abs(plane.D - separator.D) < 0.001f + && Vector3.Distance(plane.Normal, separator.Normal) < 0.001f) + { + isFront = true; + } + else + { + foreach (var point in polygon.Points) + { + if (separator.DotCoordinate(point) > 0.0f) + isFront = true; + else + isBack = true; + } + } + + if (isFront) + front.Add(polygon); + + if (isBack) + back.Add(polygon); + } + + frontNode = Build(front); + backNode = Build(back); + } + + return new AlphaBspNode(polygons[0], frontNode, backNode); + } + } +} Index: /OniSplit/Akira/AlphaBspNode.cs =================================================================== --- /OniSplit/Akira/AlphaBspNode.cs (revision 1114) +++ /OniSplit/Akira/AlphaBspNode.cs (revision 1114) @@ -0,0 +1,13 @@ +namespace Oni.Akira +{ + internal class AlphaBspNode : BspNode + { + public readonly Polygon Polygon; + + public AlphaBspNode(Polygon polygon, AlphaBspNode frontChild, AlphaBspNode backChild) + : base(polygon.Plane, frontChild, backChild) + { + Polygon = polygon; + } + } +} Index: /OniSplit/Akira/BspNode.cs =================================================================== --- /OniSplit/Akira/BspNode.cs (revision 1114) +++ /OniSplit/Akira/BspNode.cs (revision 1114) @@ -0,0 +1,17 @@ +namespace Oni.Akira +{ + internal abstract class BspNode + where T : BspNode + { + public readonly Plane Plane; + public readonly T BackChild; + public readonly T FrontChild; + + protected BspNode(Plane plane, T backChild, T frontChild) + { + Plane = plane; + BackChild = backChild; + FrontChild = frontChild; + } + } +} Index: /OniSplit/Akira/GunkFlags.cs =================================================================== --- /OniSplit/Akira/GunkFlags.cs (revision 1114) +++ /OniSplit/Akira/GunkFlags.cs (revision 1114) @@ -0,0 +1,46 @@ +using System; + +namespace Oni.Akira +{ + [Flags] + internal enum GunkFlags : uint + { + None = 0, + DoorFrame = 0x01, + + Ghost = 0x02, + StairsUp = 0x04, + StairsDown = 0x08, + + Stairs = 0x10, + Transparent = 0x80, + TwoSided = 0x0200, + NoCollision = 0x0800, + Invisible = 0x00002000, + NoObjectCollision = 0x4000, + NoCharacterCollision = 0x8000, + NoOcclusion = 0x010000, + Danger = 0x020000, + GridIgnore = 0x400000, + NoDecals = 0x800000, + Furniture = 0x01000000, + + SoundTransparent = 0x08000000, + Impassable = 0x10000000, + + Triangle = 0x00000040, + Horizontal = 0x00080000, + Vertical = 0x00100000, + + ProjectionBit0 = 0x02000000, + ProjectionBit1 = 0x04000000, + } + + internal enum PolygonProjectionPlane + { + None, + XY, + XZ, + YZ + } +} Index: /OniSplit/Akira/Material.cs =================================================================== --- /OniSplit/Akira/Material.cs (revision 1114) +++ /OniSplit/Akira/Material.cs (revision 1114) @@ -0,0 +1,51 @@ +using System; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class Material + { + private bool isMarker; + private string name; + private GunkFlags flags; + private string imageFilePath; + private Surface image; + + public Material(string name) + { + this.name = name; + } + + public Material(string name, bool isMarker) + { + this.name = name; + this.isMarker = isMarker; + } + + public string Name + { + get { return name; } + set { name = value; } + } + + public bool IsMarker => isMarker; + + public GunkFlags Flags + { + get { return flags; } + set { flags = value; } + } + + public string ImageFilePath + { + get { return imageFilePath; } + set { imageFilePath = value; } + } + + public Surface Image + { + get { return image; } + set { image = value; } + } + } +} Index: /OniSplit/Akira/MaterialLibrary.cs =================================================================== --- /OniSplit/Akira/MaterialLibrary.cs (revision 1114) +++ /OniSplit/Akira/MaterialLibrary.cs (revision 1114) @@ -0,0 +1,379 @@ +using System; +using System.Collections.Generic; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class MaterialLibrary + { + private readonly MarkerMaterials markers = new MarkerMaterials(); + private readonly Dictionary materials = new Dictionary(StringComparer.OrdinalIgnoreCase); + private Material notFound; + + #region internal class MarkerMaterials + + internal class MarkerMaterials + { + private Material ghost; + private Material stairs; + private Material door; + private Material danger; + private Material barrier; + private Material impassable; + private Material blackness; + private Material floor; + + public Material GetMarker(string name) + { + EnsureMaterials(); + + switch (name) + { + case "_marker_door": + return door; + case "_marker_ghost": + return ghost; + case "_marker_stairs": + return stairs; + case "_marker_danger": + return danger; + case "_marker_barrier": + return barrier; + case "_marker_impassable": + return impassable; + case "_marker_blackness": + return blackness; + case "_marker_floor": + return floor; + default: + return null; + } + } + + public Material GetMarker(Polygon polygon) + { + EnsureMaterials(); + + var flags = polygon.Flags & ~(GunkFlags.ProjectionBit0 | GunkFlags.ProjectionBit1 | GunkFlags.Horizontal | GunkFlags.Vertical); + var adjacencyFlags = GunkFlags.Ghost | GunkFlags.StairsUp | GunkFlags.StairsDown; + + if ((flags & (GunkFlags.DoorFrame | adjacencyFlags)) == GunkFlags.DoorFrame) + return door; + + if ((flags & adjacencyFlags) != 0) + return ghost; + + if ((flags & GunkFlags.Invisible) != 0) + { + flags &= ~GunkFlags.Invisible; + + if ((flags & GunkFlags.Danger) != 0) + return danger; + + if ((flags & GunkFlags.Stairs) != 0) + return stairs; + + if ((flags & (GunkFlags.NoObjectCollision | GunkFlags.NoCharacterCollision)) == GunkFlags.NoObjectCollision) + return barrier; + + if ((flags & (GunkFlags.NoObjectCollision | GunkFlags.NoCharacterCollision | GunkFlags.NoCollision)) == 0) + return impassable; + + // + // What's the point of a invisible and no collision polygon?! + // + + if ((flags & GunkFlags.NoCollision) != 0) + return null; + + Console.Error.WriteLine("Unknown invisible material, fix tool: {0}", flags); + } + else + { + if ((flags & (GunkFlags.TwoSided | GunkFlags.NoCollision)) == (GunkFlags.TwoSided | GunkFlags.NoCollision) + && polygon.Material != null + && polygon.Material.Name == "BLACKNESS") + { + return blackness; + } + } + + return null; + } + + private void EnsureMaterials() + { + if (ghost != null) + return; + + CreateGhost(); + CreateBarrier(); + CreateDanger(); + CreateDoor(); + CreateStairs(); + CreateImpassable(); + CreateBlackness(); + CreateFloor(); + } + + private void CreateBarrier() + { + var surface = new Surface(128, 128); + + var fill = new Color(0, 240, 20, 180); + var sign = new Color(240, 20, 0, 255); + + surface.Fill(0, 0, 128, 128, fill); + + surface.Fill(0, 0, 128, 1, sign); + surface.Fill(0, 127, 128, 1, sign); + surface.Fill(0, 1, 1, 126, sign); + surface.Fill(127, 1, 1, 126, sign); + surface.Fill(64, 1, 1, 126, sign); + surface.Fill(1, 64, 126, 1, sign); + + barrier = new Material("_marker_barrier", true) + { + Flags = GunkFlags.NoObjectCollision | GunkFlags.Invisible, + Image = surface + }; + } + + private void CreateImpassable() + { + var surface = new Surface(128, 128); + + var fill = new Color(240, 0, 20, 180); + var sign = new Color(240, 20, 0, 255); + + surface.Fill(0, 0, 128, 128, fill); + + surface.Fill(0, 0, 128, 1, sign); + surface.Fill(0, 127, 128, 1, sign); + surface.Fill(0, 1, 1, 126, sign); + surface.Fill(127, 1, 1, 126, sign); + surface.Fill(64, 1, 1, 126, sign); + surface.Fill(1, 64, 126, 1, sign); + + impassable = new Material("_marker_impassable", true) + { + Flags = GunkFlags.Invisible, + Image = surface + }; + } + + private void CreateGhost() + { + var surface = new Surface(128, 128); + + var border = new Color(16, 48, 240, 240); + var fill = new Color(208, 240, 240, 80); + + surface.Fill(0, 0, 128, 128, fill); + + surface.Fill(0, 0, 128, 1, border); + surface.Fill(0, 127, 128, 1, border); + surface.Fill(0, 1, 1, 126, border); + surface.Fill(127, 1, 1, 126, border); + surface.Fill(64, 1, 1, 126, border); + surface.Fill(1, 64, 126, 1, border); + + ghost = new Material("_marker_ghost", true); + ghost.Flags = GunkFlags.Ghost | GunkFlags.TwoSided | GunkFlags.Transparent | GunkFlags.NoCollision; + ghost.Image = surface; + } + + private void CreateDoor() + { + var surface = new Surface(128, 128); + + var fill = new Color(240, 240, 0, 208); + var line = new Color(0, 0, 240); + + surface.Fill(0, 0, 128, 128, fill); + + surface.Fill(1, 1, 126, 1, line); + surface.Fill(1, 1, 1, 126, line); + surface.Fill(1, 126, 126, 1, line); + surface.Fill(126, 1, 1, 126, line); + + door = new Material("_marker_door", true) + { + Flags = GunkFlags.DoorFrame | GunkFlags.TwoSided | GunkFlags.Transparent | GunkFlags.NoCollision, + Image = surface + }; + } + + private void CreateDanger() + { + var surface = new Surface(128, 128); + + var fill = new Color(255, 10, 0, 208); + var sign = new Color(255, 255, 255, 255); + + surface.Fill(0, 0, 128, 128, fill); + surface.Fill(52, 16, 24, 64, sign); + surface.Fill(52, 96, 24, 16, sign); + + danger = new Material("_marker_danger", true) + { + Flags = GunkFlags.Danger | GunkFlags.Invisible | GunkFlags.NoCollision | GunkFlags.NoOcclusion, + Image = surface + }; + } + + private void CreateStairs() + { + var surface = new Surface(128, 128); + + var fill = new Color(40, 240, 0, 180); + var step = new Color(40, 0, 240, 180); + + surface.Fill(0, 0, 128, 128, fill); + + for (int y = 0; y < surface.Height; y += 32) + surface.Fill(0, y, surface.Width, 16, step); + + stairs = new Material("_marker_stairs", true) + { + Flags = GunkFlags.Stairs | GunkFlags.Invisible | GunkFlags.NoObjectCollision | GunkFlags.TwoSided, + Image = surface + }; + } + + private void CreateBlackness() + { + var surface = new Surface(16, 16, SurfaceFormat.BGRX); + + surface.Fill(0, 0, 16, 16, Color.Black); + + blackness = new Material("_marker_blackness", true) + { + Flags = GunkFlags.TwoSided | GunkFlags.NoCollision, + Image = surface + }; + } + + private void CreateFloor() + { + var surface = new Surface(256, 256); + + surface.Fill(0, 0, 16, 16, Color.White); + + for (int x = 0; x < 256; x += 4) + { + surface.Fill(x, 0, 1, 256, Color.Black); + surface.Fill(0, x, 256, 1, Color.Black); + } + + floor = new Material("_marker_floor", true) + { + Flags = GunkFlags.NoCollision, + Image = surface + }; + } + + public Material Barrier + { + get + { + EnsureMaterials(); + return barrier; + } + } + + public Material Ghost + { + get + { + EnsureMaterials(); + return ghost; + } + } + + public Material Danger + { + get + { + EnsureMaterials(); + return danger; + } + } + + public Material DoorFrame + { + get + { + EnsureMaterials(); + return door; + } + } + + public Material Stairs + { + get + { + EnsureMaterials(); + return stairs; + } + } + + public Material Floor + { + get + { + EnsureMaterials(); + return floor; + } + } + + public Material Blackness + { + get + { + EnsureMaterials(); + return blackness; + } + } + } + + #endregion + + public MarkerMaterials Markers => markers; + + public Material NotFound + { + get + { + if (notFound == null) + notFound = GetMaterial("notfoundtex"); + + return notFound; + } + } + + public IEnumerable All => materials.Values; + + public Material GetMaterial(string name) + { + Material material; + + if (!materials.TryGetValue(name, out material)) + { + material = markers.GetMarker(name); + + if (material == null) + material = new Material(name); + + materials.Add(name, material); + } + + if (name.StartsWith("lmap_", StringComparison.OrdinalIgnoreCase)) + { + material.Flags |= GunkFlags.NoCollision | GunkFlags.NoOcclusion | GunkFlags.SoundTransparent; + } + + return material; + } + } +} Index: /OniSplit/Akira/OctreeBuilder.cs =================================================================== --- /OniSplit/Akira/OctreeBuilder.cs (revision 1114) +++ /OniSplit/Akira/OctreeBuilder.cs (revision 1114) @@ -0,0 +1,43 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Akira +{ + internal static class OctreeBuilder + { + private static readonly BoundingBox rootBoundingBox = new BoundingBox(new Vector3(-4096.0f), new Vector3(4096.0f)); + + public static OctreeNode Build(PolygonMesh mesh, bool debug) + { + IEnumerable polygons = mesh.Polygons; + + if (debug) + polygons = polygons.Concatenate(mesh.Ghosts); + + var root = new OctreeNode(rootBoundingBox, polygons, mesh.Rooms); + root.Build(); + return root; + } + + public static OctreeNode Build(PolygonMesh mesh, GunkFlags excludeFlags) + { + var root = new OctreeNode(rootBoundingBox, mesh.Polygons.Where(p => (p.Flags & excludeFlags) == 0), mesh.Rooms); + root.Build(); + return root; + } + + public static OctreeNode Build(PolygonMesh mesh, Func polygonFilter) + { + var root = new OctreeNode(rootBoundingBox, mesh.Polygons.Where(polygonFilter), mesh.Rooms); + root.Build(); + return root; + } + + public static OctreeNode BuildRoomsOctree(PolygonMesh mesh) + { + var root = new OctreeNode(rootBoundingBox, new Polygon[0], mesh.Rooms); + root.Build(); + return root; + } + } +} Index: /OniSplit/Akira/OctreeNode.cs =================================================================== --- /OniSplit/Akira/OctreeNode.cs (revision 1114) +++ /OniSplit/Akira/OctreeNode.cs (revision 1114) @@ -0,0 +1,492 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Akira +{ + internal class OctreeNode + { + public const int FaceCount = 6; + public const int ChildCount = 8; + + private const float MinNodeSize = 16.0f; + private const int MaxQuadsPerLeaf = 4096; + private const int MaxRoomsPerLeaf = 255; + + #region Private data + private int index; + private BoundingBox bbox; + private Polygon[] polygons; + private OctreeNode[] children; + private OctreeNode[] adjacency = new OctreeNode[FaceCount]; + private Room[] rooms; + #endregion + + #region public enum Axis + + public enum Axis + { + Z, + Y, + X + } + + #endregion + #region public enum Direction + + public enum Direction + { + Negative, + Positive + } + + #endregion + #region public struct Face + + public struct Face + { + private readonly int index; + + public Face(int index) + { + this.index = index; + } + + public int Index => index; + public Axis Axis => (Axis)(2 - ((index & 6) >> 1)); + public Direction Direction => (Direction)(index & 1); + + public static IEnumerable All + { + get + { + for (int i = 0; i < FaceCount; i++) + yield return new Face(i); + } + } + } + + #endregion + #region public struct ChildPosition + + public struct ChildPosition + { + private int index; + + public ChildPosition(int index) + { + this.index = index; + } + + public int Index => index; + + public int X => this[Axis.X]; + public int Y => this[Axis.Y]; + public int Z => this[Axis.Z]; + + public int this[Axis axis] + { + get + { + return ((index >> (int)axis) & 1); + } + set + { + int mask = (1 << (int)axis); + + if (value == 0) + index &= ~mask; + else + index |= mask; + } + } + + public static IEnumerable All + { + get + { + for (int i = 0; i < 8; i++) + yield return new ChildPosition(i); + } + } + } + + #endregion + + public OctreeNode(BoundingBox bbox, IEnumerable polygons, IEnumerable rooms) + { + this.bbox = bbox; + this.polygons = polygons.ToArray(); + this.rooms = rooms.ToArray(); + } + + private OctreeNode(BoundingBox bbox, Polygon[] polygons, Room[] rooms) + { + this.bbox = bbox; + this.polygons = polygons; + this.rooms = rooms; + } + + public int Index + { + get { return index; } + set { index = value; } + } + + public BoundingBox BoundingBox => bbox; + public OctreeNode[] Children => children; + public OctreeNode[] Adjacency => adjacency; + public bool IsLeaf => polygons != null; + public ICollection Polygons => polygons; + public ICollection Rooms => rooms; + private Vector3 Center => (bbox.Min + bbox.Max) * 0.5f; + private float Size => bbox.Max.X - bbox.Min.X; + + public void Build() + { + BuildRecursive(); + + // + // Force a split of the root node because the root cannot be a leaf. + // + + if (children == null) + Split(); + } + + private void BuildRecursive() + { + if ((polygons == null || polygons.Length <= 19) && (rooms == null || rooms.Length < 16)) + { + return; + } + + if (Size <= MinNodeSize) + { + if (polygons.Length > MaxQuadsPerLeaf) + throw new NotSupportedException(string.Format("Octtree: Quad density too big: current {0} max 4096 bbox {1}", polygons.Length, BoundingBox)); + + if (rooms.Length > MaxRoomsPerLeaf) + throw new NotSupportedException(string.Format("Octtree: Room density too big: current {0} max 255 bbox {1}", rooms.Length, BoundingBox)); + + return; + } + + Split(); + } + + private void Split() + { + children = SplitCore(); + polygons = null; + rooms = null; + + BuildSimpleAdjaceny(); + + foreach (var child in children) + child.BuildRecursive(); + } + + private OctreeNode[] SplitCore() + { + var children = new OctreeNode[ChildCount]; + var center = Center; + var childPolygons = new List(polygons.Length); + var childRooms = new List(rooms.Length); + + foreach (var position in ChildPosition.All) + { + var childNodeBBox = new BoundingBox(center, center); + + if (position.X == 0) + childNodeBBox.Min.X = bbox.Min.X; + else + childNodeBBox.Max.X = bbox.Max.X; + + if (position.Y == 0) + childNodeBBox.Min.Y = bbox.Min.Y; + else + childNodeBBox.Max.Y = bbox.Max.Y; + + if (position.Z == 0) + childNodeBBox.Min.Z = bbox.Min.Z; + else + childNodeBBox.Max.Z = bbox.Max.Z; + + childPolygons.Clear(); + childRooms.Clear(); + + var boxIntersector = new PolygonBoxIntersector(ref childNodeBBox); + + foreach (var polygon in polygons) + { + if (boxIntersector.Intersects(polygon)) + childPolygons.Add(polygon); + } + + foreach (var room in rooms) + { + if (room.Intersect(childNodeBBox)) + childRooms.Add(room); + } + + children[position.Index] = new OctreeNode(childNodeBBox, childPolygons.ToArray(), childRooms.ToArray()); + } + + return children; + } + + private void BuildSimpleAdjaceny() + { + foreach (ChildPosition position in ChildPosition.All) + { + var child = children[position.Index]; + + foreach (var face in Face.All) + child.Adjacency[face.Index] = GetChildAdjacency(position, face); + } + } + + private OctreeNode GetChildAdjacency(ChildPosition position, Face face) + { + if (face.Direction == Direction.Positive) + { + if (position[face.Axis] == 0) + { + position[face.Axis] = 1; + return children[position.Index]; + } + } + else + { + if (position[face.Axis] == 1) + { + position[face.Axis] = 0; + return children[position.Index]; + } + } + + return adjacency[face.Index]; + } + + public void RefineAdjacency() + { + Vector3 center = Center; + float size = Size; + + foreach (var face in Face.All) + { + var node = adjacency[face.Index]; + + if (node != null && !node.IsLeaf && node.Size > Size) + { + Vector3 adjacentCenter = MovePoint(center, face, size); + adjacency[face.Index] = node.FindLargestOrEqual(adjacentCenter, size); + } + } + } + + public QuadtreeNode BuildFaceQuadTree(Face face) + { + Vector3 faceCenter = MovePoint(Center, face, Size * 0.5f); + var quadTreeNode = new QuadtreeNode(faceCenter, Size, face); + quadTreeNode.Build(adjacency[face.Index]); + return quadTreeNode; + } + + public void DfsTraversal(Action action) + { + action(this); + + if (!IsLeaf) + { + foreach (var child in children) + child.DfsTraversal(action); + } + } + + public static Vector3 MovePoint(Vector3 point, Face face, float delta) + { + if (face.Direction == Direction.Negative) + delta = -delta; + + if (face.Axis == Axis.X) + point.X += delta; + else if (face.Axis == Axis.Y) + point.Y += delta; + else + point.Z += delta; + + return point; + } + + private struct TriangleBoxIntersector + { + private Vector3 center; + private Vector3 size; + private Vector3[] triangle; + private Vector3 edge; + + public TriangleBoxIntersector(ref BoundingBox box) + { + center = (box.Min + box.Max) * 0.5f; + size = (box.Max - box.Min) * 0.5f; + + triangle = new Vector3[3]; + edge = Vector3.Zero; + } + + public Vector3[] Triangle => triangle; + + public bool Intersect() + { + for (int i = 0; i < triangle.Length; i++) + triangle[i] -= center; + + edge = triangle[1] - triangle[0]; + + if (AxisTest(Y, Z, 0, 2) || AxisTest(Z, X, 0, 2) || AxisTest(X, Y, 2, 1)) + return false; + + edge = triangle[2] - triangle[1]; + + if (AxisTest(Y, Z, 0, 2) || AxisTest(Z, X, 0, 2) || AxisTest(X, Y, 0, 1)) + return false; + + edge = triangle[0] - triangle[2]; + + if (AxisTest(Y, Z, 0, 1) || AxisTest(Z, X, 0, 1) || AxisTest(X, Y, 2, 1)) + return false; + + return true; + } + + private const int X = 0; + private const int Y = 1; + private const int Z = 2; + + private bool AxisTest(int a1, int a2, int p0, int p1) + { + Vector3 v0 = triangle[p0]; + Vector3 v1 = triangle[p1]; + float e1 = edge[a1]; + float e2 = edge[a2]; + + float c0 = e2 * v0[a1] - e1 * v0[a2]; + float c1 = e2 * v1[a1] - e1 * v1[a2]; + float rad = Math.Abs(e2) * size[a1] + Math.Abs(e1) * size[a2]; + + return (c0 < c1) ? (c0 > rad || c1 < -rad) : (c1 > rad || c0 < -rad); + } + } + + private struct PolygonBoxIntersector + { + private BoundingBox bbox; + private TriangleBoxIntersector triangleBoxIntersector; + + public PolygonBoxIntersector(ref BoundingBox bbox) + { + this.bbox = bbox; + this.triangleBoxIntersector = new TriangleBoxIntersector(ref bbox); + } + + public bool Intersects(Polygon polygon) + { + if (!bbox.Intersects(polygon.BoundingBox)) + return false; + + if (!bbox.Intersects(polygon.Plane)) + return false; + + var intersector = new TriangleBoxIntersector(ref bbox); + var points = polygon.Mesh.Points; + var indices = polygon.PointIndices; + + intersector.Triangle[0] = points[indices[0]]; + intersector.Triangle[1] = points[indices[1]]; + intersector.Triangle[2] = points[indices[2]]; + + if (intersector.Intersect()) + return true; + + if (indices.Length > 3) + { + intersector.Triangle[0] = points[indices[2]]; + intersector.Triangle[1] = points[indices[3]]; + intersector.Triangle[2] = points[indices[0]]; + + if (intersector.Intersect()) + return true; + } + + return false; + } + } + + public OctreeNode FindLargestOrEqual(Vector3 point, float largestSize) + { + var node = this; + + while (!node.IsLeaf && node.Size > largestSize) + { + Vector3 center = node.Center; + + int nx = (point.X < center.X) ? 0 : 4; + int ny = (point.Y < center.Y) ? 0 : 2; + int nz = (point.Z < center.Z) ? 0 : 1; + + var childNode = node.children[nx + ny + nz]; + + if (childNode.Size < largestSize) + break; + + node = childNode; + } + + return node; + } + + public OctreeNode FindLeaf(Vector3 point) + { + if (!bbox.Contains(point)) + return null; + + if (children == null) + return this; + + Vector3 center = Center; + + int nx = (point.X < center.X) ? 0 : 4; + int ny = (point.Y < center.Y) ? 0 : 2; + int nz = (point.Z < center.Z) ? 0 : 1; + + OctreeNode childNode = children[nx + ny + nz]; + + return childNode.FindLeaf(point); + } + + public IEnumerable FindLeafs(BoundingBox box) + { + var stack = new Stack(); + stack.Push(this); + + while (stack.Count > 0) + { + var node = stack.Pop(); + + if (node.bbox.Intersects(box)) + { + if (node.children != null) + { + foreach (OctreeNode child in node.children) + stack.Push(child); + } + else + { + yield return node; + } + } + } + } + } +} Index: /OniSplit/Akira/Polygon.cs =================================================================== --- /OniSplit/Akira/Polygon.cs (revision 1114) +++ /OniSplit/Akira/Polygon.cs (revision 1114) @@ -0,0 +1,293 @@ +using System; +using System.Collections.Generic; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class Polygon + { + #region Private data + private PolygonMesh mesh; + private GunkFlags flags; + private int[] pointIndices; + private int[] texCoordIndices; + private int[] normalIndices; + private Color[] colors; + private Material material; + private Plane plane; + private int objectType = -1; + private int objectId = -1; + private int scriptId; + private string fileName; + private string objectName; + private PolygonEdge[] edges; + private BoundingBox bbox; + #endregion + + public Polygon(PolygonMesh mesh, int[] pointIndices) + { + this.mesh = mesh; + this.pointIndices = pointIndices; + this.plane = GetPlane(); + this.bbox = GetBoundingBox(); + + BuildFlags(); + } + + public Polygon(PolygonMesh mesh, int[] pointIndices, GunkFlags flags) + : this(mesh, pointIndices) + { + this.flags |= flags; + } + + public Polygon(PolygonMesh mesh, int[] pointIndices, Plane plane) + { + this.mesh = mesh; + this.pointIndices = pointIndices; + this.plane = plane; + + BuildFlags(); + } + + public PolygonMesh Mesh => mesh; + + public GunkFlags Flags + { + get + { + if (material == null) + return flags; + + return flags | material.Flags; + } + set + { + flags = value; + } + } + + public bool IsTransparent => (Flags & GunkFlags.Transparent) != 0; + public bool IsStairs=>(Flags & GunkFlags.Stairs) != 0; + + public Material Material + { + get { return material; } + set { material = value; } + } + + public int VertexCount => pointIndices.Length; + + public int[] PointIndices => pointIndices; + + public IEnumerable Points + { + get + { + foreach (int i in pointIndices) + yield return mesh.Points[i]; + } + } + + public int[] TexCoordIndices + { + get { return texCoordIndices; } + set { texCoordIndices = value; } + } + + public int[] NormalIndices + { + get { return normalIndices; } + set { normalIndices = value; } + } + + public Color[] Colors + { + get { return colors; } + set { colors = value; } + } + + public Plane Plane => plane; + + public int ObjectType + { + get { return objectType; } + set { objectType = value; } + } + + public int ObjectId + { + get { return objectId; } + set { objectId = value; } + } + + public int ScriptId + { + get { return scriptId; } + set { scriptId = value; } + } + + public string FileName + { + get { return fileName; } + set { fileName = value; } + } + + public string ObjectName + { + get { return objectName; } + set { objectName = value; } + } + + private Plane GetPlane() + { + var plane = new Plane( + mesh.Points[pointIndices[0]], + mesh.Points[pointIndices[1]], + mesh.Points[pointIndices[2]]); + + var bbox = GetBoundingBox(); + var bboxSize = bbox.Max - bbox.Min; + + if (Math.Abs(bboxSize.X) < 0.0001f) + { + if (plane.Normal.X < 0.0f) + plane = new Plane(Vector3.Left, bbox.Min.X); + else + plane = new Plane(Vector3.Right, -bbox.Max.X); + } + else if (Math.Abs(bboxSize.Y) < 0.0001f) + { + if (plane.Normal.Y < 0.0f) + plane = new Plane(Vector3.Down, bbox.Min.Y); + else + plane = new Plane(Vector3.Up, -bbox.Max.Y); + } + else if (Math.Abs(bboxSize.Z) < 0.0001f) + { + if (plane.Normal.Z < 0.0f) + plane = new Plane(Vector3.Forward, bbox.Min.Z); + else + plane = new Plane(Vector3.Backward, -bbox.Max.Z); + } + else + { + plane.Normal.X = FMath.Round(plane.Normal.X, 4); + plane.Normal.Y = FMath.Round(plane.Normal.Y, 4); + plane.Normal.Z = FMath.Round(plane.Normal.Z, 4); + } + + return plane; + } + + public BoundingBox BoundingBox => bbox; + + private BoundingBox GetBoundingBox() + { + var point = mesh.Points[pointIndices[0]]; + var bbox = new BoundingBox(point, point); + + for (int i = 1; i < pointIndices.Length; i++) + { + point = mesh.Points[pointIndices[i]]; + + Vector3.Min(ref bbox.Min, ref point, out bbox.Min); + Vector3.Max(ref bbox.Max, ref point, out bbox.Max); + } + + return bbox; + } + + private void BuildFlags() + { + SetProjectionPlane(); + SetHorizontalVertical(); + } + + private void SetHorizontalVertical() + { + if (Math.Abs(Vector3.Dot(plane.Normal, Vector3.UnitY)) < 0.3420201f) + flags |= GunkFlags.Vertical; + else + flags |= GunkFlags.Horizontal; + } + + private void SetProjectionPlane() + { + var points = new Vector3[pointIndices.Length]; + + for (int i = 0; i < pointIndices.Length; i++) + points[i] = mesh.Points[pointIndices[i]]; + + float xyArea = MathHelper.Area(Project(points, PolygonProjectionPlane.XY)); + float yzArea = MathHelper.Area(Project(points, PolygonProjectionPlane.YZ)); + float xzArea = MathHelper.Area(Project(points, PolygonProjectionPlane.XZ)); + + var plane = PolygonProjectionPlane.None; + + if (xyArea > yzArea) + { + if (xyArea > xzArea) + plane = PolygonProjectionPlane.XY; + else + plane = PolygonProjectionPlane.XZ; + } + else + { + if (yzArea > xzArea) + plane = PolygonProjectionPlane.YZ; + else + plane = PolygonProjectionPlane.XZ; + } + + flags |= (GunkFlags)((int)plane << 25); + } + + private static Vector2[] Project(Vector3[] points, PolygonProjectionPlane plane) + { + var result = new Vector2[points.Length]; + + switch (plane) + { + case PolygonProjectionPlane.XY: + for (int i = 0; i < points.Length; i++) + { + result[i].X = points[i].X; + result[i].Y = points[i].Y; + } + break; + case PolygonProjectionPlane.XZ: + for (int i = 0; i < points.Length; i++) + { + result[i].X = points[i].X; + result[i].Y = points[i].Z; + } + break; + case PolygonProjectionPlane.YZ: + for (int i = 0; i < points.Length; i++) + { + result[i].X = points[i].Z; + result[i].Y = points[i].Y; + } + break; + } + + return result; + } + + public PolygonEdge[] Edges + { + get + { + if (edges == null) + { + edges = new PolygonEdge[pointIndices.Length]; + + for (int i = 0; i < edges.Length; i++) + edges[i] = new PolygonEdge(this, i); + } + + return edges; + } + } + } +} Index: /OniSplit/Akira/Polygon2Clipper.cs =================================================================== --- /OniSplit/Akira/Polygon2Clipper.cs (revision 1114) +++ /OniSplit/Akira/Polygon2Clipper.cs (revision 1114) @@ -0,0 +1,247 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Akira +{ + internal struct Polygon2Clipper + { + private readonly List result; + private readonly RoomBspNode bspTree; + + #region private struct Line + + private struct Line + { + private float a, c, d; + + public Line(Plane plane) + { + a = plane.Normal.X; + c = plane.Normal.Z; + d = plane.D; + } + + public int RelativePosition(Vector2 point) + { + float r = a * point.X + c * point.Y + d; + + if (r < -0.00001f) + return -1; + else if (r > 0.00001f) + return 1; + else + return 0; + } + + public Vector2 Intersect(Vector2 p0, Vector2 p1) + { + if (p0.X == p1.X) + { + float x = p0.X; + float y = (d + a * x) / -c; + return new Vector2(x, y); + } + else if (p0.Y == p1.Y) + { + float x = (-c * p0.Y - d) / a; + float y = p0.Y; + return new Vector2(x, y); + } + else + { + float m = (p1.Y - p0.Y) / (p1.X - p0.X); + float x = (c * m * p0.X - c * p0.Y - d) / (a + c * m); + float y = m * (x - p0.X) + p0.Y; + return new Vector2(x, y); + } + } + } + + #endregion + + public Polygon2Clipper(RoomBspNode bspTree) + { + this.result = new List(); + this.bspTree = bspTree; + } + + public IEnumerable Clip(Polygon2 polygon) + { + result.Clear(); + Clip(new[] { polygon }, bspTree); + return result; + } + + private void Clip(IEnumerable polygons, RoomBspNode node) + { + var negative = new List(); + var positive = new List(); + + var plane = node.Plane; + + if (Math.Abs(plane.Normal.Y) > 0.001f) + { + negative.AddRange(polygons); + positive.AddRange(polygons); + } + else + { + var line = new Line(plane); + + foreach (Polygon2 polygon in polygons) + Clip(polygon, line, negative, positive); + } + + if (node.FrontChild != null) + Clip(positive, node.FrontChild); + + if (node.BackChild != null) + Clip(negative, node.BackChild); + else + result.AddRange(negative); + } + + private static void Clip(Polygon2 polygon, Line line, List negative, List positive) + { + var signs = new int[polygon.Length]; + int positiveCount = 0, negativeCount = 0; + + for (int i = 0; i < polygon.Length; i++) + { + signs[i] = line.RelativePosition(polygon[i]); + + if (signs[i] >= 0) + positiveCount++; + + if (signs[i] <= 0) + negativeCount++; + } + + if (negativeCount == polygon.Length) + { + // + // All points are in the negative half plane, nothing to clip. + // + + negative.Add(polygon); + return; + } + + if (positiveCount == polygon.Length) + { + // + // All points are in the positive half plane, nothing to clip. + // + + positive.Add(polygon); + return; + } + + var negativePoints = new List(); + var positivePoints = new List(); + + int start = 0; + Vector2 p0; + int s0; + + do + { + p0 = polygon[start]; + s0 = signs[start]; + start++; + + // + // do not start right on the clip line + // + + } while (s0 == 0); + + var intersections = new Vector2[2]; + int intersectionCount = 0; + + for (int i = 0; i < polygon.Length; i++) + { + Vector2 p1 = polygon[(i + start) % polygon.Length]; + int s1 = signs[(i + start) % polygon.Length]; + + if (s0 == s1) + { + // + // Same half plane, no intersection, add the existing edge. + // + + if (s0 < 0) + negativePoints.Add(p0); + else + positivePoints.Add(p0); + } + else if (s0 == 0) + { + // + // If the previous point was on the clip line then we need + // to use the current point sign to figure out the destination polygon. + // + + if (s1 < 0) + negativePoints.Add(p0); + else + positivePoints.Add(p0); + } + else + { + // + // Different half plane, split the edge in two. + // + + Vector2 intersection; + + if (s1 == 0) + intersection = p1; + else + intersection = line.Intersect(p0, p1); + + intersections[intersectionCount++] = intersection; + + if (s0 < 0) + { + // the negative polygon needs to be closed + // the positive polygon needs to have an edge added from the previous intersection to the new one + + negativePoints.Add(p0); + + if (intersectionCount == 2) + { + negativePoints.Add(intersection); + positivePoints.Add(intersections[0]); + } + + if (s1 != 0) + positivePoints.Add(intersection); + } + else + { + // the positive polygon needs to be closed + // the negative polygon needs to have an edge added from the previous intersection to the new one + + positivePoints.Add(p0); + + if (intersectionCount == 2) + { + positivePoints.Add(intersection); + negativePoints.Add(intersections[0]); + } + + if (s1 != 0) + negativePoints.Add(intersection); + } + } + + p0 = p1; + s0 = s1; + } + + negative.Add(new Polygon2(negativePoints.ToArray())); + positive.Add(new Polygon2(positivePoints.ToArray())); + } + } +} Index: /OniSplit/Akira/PolygonEdge.cs =================================================================== --- /OniSplit/Akira/PolygonEdge.cs (revision 1114) +++ /OniSplit/Akira/PolygonEdge.cs (revision 1114) @@ -0,0 +1,32 @@ +using System; + +namespace Oni.Akira +{ + internal class PolygonEdge + { + private static readonly PolygonEdge[] emptyEdges = new PolygonEdge[0]; + private readonly Polygon polygon; + private readonly int index; + private PolygonEdge[] adjacency = emptyEdges; + + public PolygonEdge(Polygon polygon, int index) + { + this.polygon = polygon; + this.index = index; + } + + public Polygon Polygon => polygon; + + public int Index => index; + public int EndIndex => (index + 1) % polygon.Edges.Length; + + public int Point0Index => polygon.PointIndices[index]; + public int Point1Index => polygon.PointIndices[EndIndex]; + + public PolygonEdge[] Adjancency + { + get { return adjacency; } + set { adjacency = value; } + } + } +} Index: /OniSplit/Akira/PolygonMesh.cs =================================================================== --- /OniSplit/Akira/PolygonMesh.cs (revision 1114) +++ /OniSplit/Akira/PolygonMesh.cs (revision 1114) @@ -0,0 +1,105 @@ +using System; +using System.Collections.Generic; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class PolygonMesh + { + private readonly MaterialLibrary materialLibrary; + private readonly List points = new List(); + private readonly List normals = new List(); + private readonly List texCoords = new List(); + private readonly List polygons = new List(); + private readonly List doors = new List(); + private readonly List rooms = new List(); + private readonly List ghosts = new List(); + private readonly List floors = new List(); + private bool hasDebugInfo; + + public PolygonMesh(MaterialLibrary materialLibrary) + { + this.materialLibrary = materialLibrary; + } + + public MaterialLibrary Materials => materialLibrary; + + public List Points => points; + public List TexCoords => texCoords; + public List Normals => normals; + public List Polygons => polygons; + public List Doors => doors; + public List Rooms => rooms; + public List Floors => floors; + public List Ghosts => ghosts; + + public bool HasDebugInfo + { + get { return hasDebugInfo; } + set { hasDebugInfo = value; } + } + + public BoundingBox GetBoundingBox() => BoundingBox.CreateFromPoints(points); + + public void DoLighting() + { + var ambientColor = new Vector3(0.6f, 0.6f, 0.6f); + + var lightDir = new[] { + new Vector3(-0.526f, -0.573f, -0.627f), + new Vector3(0.719f, 0.342f, 0.604f), + new Vector3(0.454f, 0.766f, 0.454f) + }; + + var lightColor = new[] { + new Vector3(1.0f, 1.0f, 1.0f), + new Vector3(1.0f, 1.0f, 1.0f), + new Vector3(1.0f, 1.0f, 1.0f) + }; + + //if (importLights) + //{ + // ambientColor = ambient; + //} + + foreach (var polygon in polygons) + { + if (polygon.Colors != null) + continue; + + var colors = new Color[polygon.VertexCount]; + + if (polygon.NormalIndices != null) + { + for (int i = 0; i < colors.Length; i++) + { + var color = ambientColor; + + for (int j = 0; j < lightDir.Length; j++) + { + float dot = Vector3.Dot(lightDir[j], normals[polygon.NormalIndices[i]]); + color += lightColor[j] * dot; + } + + colors[i] = new Color(Vector3.Clamp(color, Vector3.Zero, Vector3.One)); + } + } + else + { + var color = ambientColor; + + for (int j = 0; j < lightDir.Length; j++) + { + float dot = Vector3.Dot(lightDir[j], polygon.Plane.Normal); + color += lightColor[j] * dot; + } + + for (int i = 0; i < colors.Length; i++) + colors[i] = new Color(Vector3.Clamp(color, Vector3.Zero, Vector3.One)); + } + + polygon.Colors = colors; + } + } + } +} Index: /OniSplit/Akira/PolygonQuadrangulate.cs =================================================================== --- /OniSplit/Akira/PolygonQuadrangulate.cs (revision 1114) +++ /OniSplit/Akira/PolygonQuadrangulate.cs (revision 1114) @@ -0,0 +1,269 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Akira +{ + internal class PolygonQuadrangulate + { + private readonly PolygonMesh mesh; + + public PolygonQuadrangulate(PolygonMesh mesh) + { + this.mesh = mesh; + } + + public void Execute() + { + GenerateAdjacency(); + + var candidates = new List(); + var polygons = mesh.Polygons; + + var newPolygons = new Polygon[polygons.Count]; + var marked = new bool[polygons.Count]; + int quadCount = 0; + + for (int i = 0; i < polygons.Count; i++) + { + var p1 = polygons[i]; + + if (marked[i] || p1.Edges.Length != 3) + continue; + + candidates.Clear(); + + foreach (PolygonEdge e1 in p1.Edges) + { + foreach (PolygonEdge e2 in e1.Adjancency) + { + if (marked[polygons.IndexOf(e2.Polygon)]) + continue; + + if (QuadCandidate.IsQuadCandidate(e1, e2)) + candidates.Add(new QuadCandidate(e1, e2)); + } + } + + if (candidates.Count > 0) + { + candidates.Sort(); + newPolygons[i] = candidates[0].CreateQuad(mesh); + + int k = polygons.IndexOf(candidates[0].Polygon2); + + marked[i] = true; + marked[k] = true; + + quadCount++; + } + } + + var newPolygonList = new List(polygons.Count - quadCount); + + for (int i = 0; i < polygons.Count; i++) + { + if (newPolygons[i] != null) + newPolygonList.Add(newPolygons[i]); + else if (!marked[i]) + newPolygonList.Add(polygons[i]); + } + + polygons = newPolygonList; + } + + #region private class QuadCandidate + + private class QuadCandidate : IComparable + { + private PolygonEdge e1; + private PolygonEdge e2; + private float l; + + public static bool IsQuadCandidate(PolygonEdge e1, PolygonEdge e2) + { + // + // To merge 2 polygons into one the following must be true: + // - both must be triangles + // - they must share the same plane + // - they must use the same material + // - TODO: the resulting polygon must be convex!!! + // - TODO: must have the same texture coordinates + // + + Polygon p1 = e1.Polygon; + Polygon p2 = e2.Polygon; + + return ( + p1.Edges.Length == 3 + && p2.Edges.Length == 3 + && p1.Plane == p2.Plane + && p1.Material == p2.Material + //&& e1.Point0Index == e2.Point0Index + //&& e1.Point1Index == e2.Point1Index + ); + } + + public QuadCandidate(PolygonEdge e1, PolygonEdge e2) + { + this.e1 = e1; + this.e2 = e2; + + List points = e1.Polygon.Mesh.Points; + this.l = Vector3.DistanceSquared(points[e1.Point0Index], points[e1.Point1Index]); + } + + public Polygon Polygon1 => e1.Polygon; + public Polygon Polygon2 => e2.Polygon; + + public int CompareTo(QuadCandidate other) + { + return l.CompareTo(other.l); + } + + public Polygon CreateQuad(PolygonMesh mesh) + { + int[] newPoints = new int[4]; + int[] newTexCoords = new int[4]; + int l = 0; + + newPoints[l] = e1.Polygon.PointIndices[e1.EndIndex]; + newTexCoords[l] = e1.Polygon.TexCoordIndices[e1.EndIndex]; + l++; + + for (int k = 0; k < 3; k++) + { + if (k != e1.Index && k != e1.EndIndex) + { + newPoints[l] = e1.Polygon.PointIndices[k]; + newTexCoords[l] = e1.Polygon.TexCoordIndices[k]; + l++; + + break; + } + } + + newPoints[l] = e1.Polygon.PointIndices[e1.Index]; + newTexCoords[l] = e1.Polygon.TexCoordIndices[e1.Index]; + l++; + + for (int k = 0; k < 3; k++) + { + if (k != e2.Index && k != e2.EndIndex) + { + newPoints[l] = e2.Polygon.PointIndices[k]; + newTexCoords[l] = e2.Polygon.TexCoordIndices[k]; + l++; + + break; + } + } + + return new Polygon(mesh, newPoints, e1.Polygon.Plane) + { + TexCoordIndices = newTexCoords, + Material = e1.Polygon.Material + }; + } + } + + #endregion + + private void GenerateAdjacency() + { + var points = mesh.Points; + var polygons = mesh.Polygons; + + var pointUseCount = new int[points.Count]; + var pointUsage = new int[points.Count][]; + + foreach (var polygon in polygons) + { + foreach (int i in polygon.PointIndices) + pointUseCount[i]++; + } + + for (int polygon = 0; polygon < polygons.Count; polygon++) + { + foreach (int i in polygons[polygon].PointIndices) + { + int useCount = pointUseCount[i]; + int[] pa = pointUsage[i]; + + if (pa == null) + { + pa = new int[useCount]; + pointUsage[i] = pa; + } + + pa[pa.Length - useCount] = polygon; + pointUseCount[i] = useCount - 1; + } + } + + var adjacencyBuffer = new List(); + + foreach (var p1 in polygons) + { + foreach (var e1 in p1.Edges) + { + adjacencyBuffer.Clear(); + + int[] a0 = pointUsage[e1.Point0Index]; + int[] a1 = pointUsage[e1.Point1Index]; + + if (a0 == null || a1 == null) + continue; + + foreach (int pi2 in MatchSortedArrays(a0, a1)) + { + var p2 = polygons[pi2]; + + if (p2 == p1) + continue; + + foreach (var e2 in p2.Edges) + { + if (e1.Point0Index == e2.Point1Index && e1.Point1Index == e2.Point0Index + || e1.Point0Index == e2.Point0Index && e1.Point1Index == e2.Point1Index) + { + adjacencyBuffer.Add(e2); + } + } + } + + e1.Adjancency = adjacencyBuffer.ToArray(); + } + } + } + + private static IEnumerable MatchSortedArrays(int[] a1, int[] a2) + { + int l1 = a1.Length; + int l2 = a2.Length; + int i1 = 0; + int i2 = 0; + + while (i1 < l1 && i2 < l2) + { + int v1 = a1[i1]; + int v2 = a2[i2]; + + if (v1 < v2) + { + i1++; + } + else if (v1 > v2) + { + i2++; + } + else + { + i1++; + i2++; + + yield return v1; + } + } + } + } +} Index: /OniSplit/Akira/PolygonUtils.cs =================================================================== --- /OniSplit/Akira/PolygonUtils.cs (revision 1114) +++ /OniSplit/Akira/PolygonUtils.cs (revision 1114) @@ -0,0 +1,95 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Akira +{ + internal class PolygonUtils + { + public static List ClipToPlane(List points, Plane plane) + { + var signs = new int[points.Count]; + var negativeCount = 0; + var positiveCount = 0; + var start = 0; + + for (int i = 0; i < points.Count; i++) + { + signs[i] = RelativePosition(points[i], plane); + + if (signs[i] >= 0) + positiveCount++; + + if (signs[i] <= 0) + negativeCount++; + } + + if (negativeCount == points.Count) + return null; + + if (positiveCount == points.Count) + return points; + + var newPoints = new List(); + + for (int i = 0; i < points.Count; i++) + { + int i0 = (i + start) % points.Count; + int i1 = (i + start + 1) % points.Count; + + int s0 = signs[i0]; + int s1 = signs[i1]; + + if (s0 >= 0) + { + newPoints.Add(points[i0]); + + if (s0 > 0 && s1 < 0) + newPoints.Add(Intersect(points[i0], points[i1], plane)); + } + else + { + if (s0 < 0 && s1 > 0) + newPoints.Add(Intersect(points[i1], points[i0], plane)); + } + } + + return newPoints; + } + + private static Vector3 Intersect(Vector3 p0, Vector3 p1, Plane plane) + { + Vector3 dir = p1 - p0; + + float dND = plane.DotNormal(dir); + + if (Math.Abs(dND) < 1e-05f) + throw new InvalidOperationException(); + + float distance = (-plane.D - plane.DotNormal(p0)) / dND; + + if (distance < 0.0f) + { + if (distance < -1e-05f) + throw new InvalidOperationException(); + + return p0; + } + else + { + return p0 + dir * distance; + } + } + + private static int RelativePosition(Vector3 point, Plane plane) + { + float pos = plane.DotCoordinate(point); + + if (pos < -1e-05f) + return -1; + else if (pos > 1e-05f) + return 1; + else + return 0; + } + } +} Index: /OniSplit/Akira/QuadtreeNode.cs =================================================================== --- /OniSplit/Akira/QuadtreeNode.cs (revision 1114) +++ /OniSplit/Akira/QuadtreeNode.cs (revision 1114) @@ -0,0 +1,134 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Akira +{ + internal class QuadtreeNode + { + public const int ChildCount = 4; + private QuadtreeNode[] nodes = new QuadtreeNode[ChildCount]; + private OctreeNode[] leafs = new OctreeNode[ChildCount]; + private readonly Vector3 center; + private readonly float size; + private readonly OctreeNode.Face face; + private int index; + + public enum Axis + { + U = 0, + V = 1 + } + + public struct ChildPosition + { + private readonly int index; + + public ChildPosition(int index) + { + this.index = index; + } + + public int Index => index; + + public int U => this[Axis.U]; + public int V => this[Axis.V]; + + public int this[Axis axis] => ((index >> (int)axis) & 1); + + public static IEnumerable All + { + get + { + for (int i = 0; i < 4; i++) + yield return new ChildPosition(i); + } + } + } + + public QuadtreeNode(Vector3 center, float size, OctreeNode.Face face) + { + this.center = center; + this.size = size; + this.face = face; + } + + public QuadtreeNode[] Nodes => nodes; + public OctreeNode[] Leafs => leafs; + + public void Build(OctreeNode adjacentNode) + { + float childSize = size * 0.5f; + + foreach (var position in ChildPosition.All) + { + var childCenter = GetChildNodeCenter(position); + var adjacentCenter = OctreeNode.MovePoint(childCenter, face, childSize * 0.5f); + var childAdjacentNode = adjacentNode.FindLargestOrEqual(adjacentCenter, childSize); + + if (childAdjacentNode.IsLeaf) + { + leafs[position.Index] = childAdjacentNode; + } + else + { + var child = new QuadtreeNode(childCenter, childSize, face); + child.Build(childAdjacentNode); + nodes[position.Index] = child; + } + } + } + + private Vector3 GetChildNodeCenter(ChildPosition position) + { + float offset = size * 0.25f; + + float u = (position.U == 0) ? -offset : offset; + float v = (position.V == 0) ? -offset : offset; + + var result = center; + + if (face.Axis == OctreeNode.Axis.X) + { + result.Y += u; + result.Z += v; + } + else if (face.Axis == OctreeNode.Axis.Y) + { + result.X += u; + result.Z += v; + } + else + { + result.X += u; + result.Y += v; + } + + return result; + } + + public int Index => index; + + public List GetDfsList() + { + var list = new List(); + + DfsTraversal(node => { + node.index = list.Count; + list.Add(node); + }); + + return list; + } + + private void DfsTraversal(Action action) + { + action(this); + + foreach (var node in nodes) + { + if (node != null) + node.DfsTraversal(action); + } + } + } +} Index: /OniSplit/Akira/Room.cs =================================================================== --- /OniSplit/Akira/Room.cs (revision 1114) +++ /OniSplit/Akira/Room.cs (revision 1114) @@ -0,0 +1,139 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Akira +{ + internal class Room + { + private Polygon floorPolygon; + private RoomBspNode bspTree; + private BoundingBox boundingBox; + private RoomGrid grid; + private Plane floorPlane; + private float height; + private readonly List adjacencies = new List(); + + public BoundingBox BoundingBox + { + get { return boundingBox; } + set { boundingBox = value; } + } + + public RoomBspNode BspTree + { + get { return bspTree; } + set { bspTree = value; } + } + + public RoomGrid Grid + { + get { return grid; } + set { grid = value; } + } + + public Polygon FloorPolygon + { + get { return floorPolygon; } + set { floorPolygon = value; } + } + + public Plane FloorPlane + { + get { return floorPlane; } + set { floorPlane = value; } + } + + public bool IsStairs => floorPlane.Normal.Y < 0.999f; + + public float Height + { + get { return height; } + set { height = value; } + } + + public List Ajacencies => adjacencies; + + public bool Contains(Vector3 point) + { + if (!boundingBox.Contains(point)) + return false; + + bool front = false; + RoomBspNode node = bspTree; + + while (node != null) + { + front = (node.Plane.DotCoordinate(point) >= MathHelper.Eps); + node = front ? node.FrontChild : node.BackChild; + } + + return !front; + } + + public bool Intersect(BoundingBox bbox) + { + if (!boundingBox.Intersects(bbox)) + return false; + + bool front = false; + RoomBspNode node = bspTree; + + while (node != null) + { + int intersects = node.Plane.Intersects(bbox); + + if (intersects == 0) + return true; + + front = intersects > 0; + node = front ? node.FrontChild : node.BackChild; + } + + return !front; + } + + public List GetFloorPolygons() + { + var polys = new List(); + + if (floorPolygon != null) + { + polys.Add(floorPolygon.Points.ToArray()); + return polys; + } + + var min = new Vector2(boundingBox.Min.X, boundingBox.Min.Z); + var max = new Vector2(boundingBox.Max.X, boundingBox.Max.Z); + + var root = new Polygon2(new[] + { + new Vector2(min.X, min.Y), + new Vector2(max.X, min.Y), + new Vector2(max.X, max.Y), + new Vector2(min.X, max.Y) + }); + + var cutter = new Polygon2Clipper(bspTree); + + foreach (Polygon2 polygon in cutter.Clip(root)) + { + var points = new Vector3[polygon.Length]; + + for (int i = 0; i < points.Length; i++) + { + var point = polygon[i]; + + points[i].X = point.X; + points[i].Y = (-floorPlane.D - floorPlane.Normal.Z * point.Y - floorPlane.Normal.X * point.X) / floorPlane.Normal.Y; + points[i].Z = point.Y; + } + + Array.Reverse(points); + + polys.Add(points); + } + + return polys; + } + } +} Index: /OniSplit/Akira/RoomAdjacency.cs =================================================================== --- /OniSplit/Akira/RoomAdjacency.cs (revision 1114) +++ /OniSplit/Akira/RoomAdjacency.cs (revision 1114) @@ -0,0 +1,18 @@ +namespace Oni.Akira +{ + internal class RoomAdjacency + { + private readonly Room adjacentRoom; + private readonly Polygon ghost; + + public RoomAdjacency(Room room, Polygon ghost) + { + this.adjacentRoom = room; + this.ghost = ghost; + } + + public Room AdjacentRoom => adjacentRoom; + + public Polygon Ghost => ghost; + } +} Index: /OniSplit/Akira/RoomBspNode.cs =================================================================== --- /OniSplit/Akira/RoomBspNode.cs (revision 1114) +++ /OniSplit/Akira/RoomBspNode.cs (revision 1114) @@ -0,0 +1,10 @@ +namespace Oni.Akira +{ + internal class RoomBspNode : BspNode + { + public RoomBspNode(Plane plane, RoomBspNode backChild, RoomBspNode frontChild) + : base(plane, backChild, frontChild) + { + } + } +} Index: /OniSplit/Akira/RoomBuilder.cs =================================================================== --- /OniSplit/Akira/RoomBuilder.cs (revision 1114) +++ /OniSplit/Akira/RoomBuilder.cs (revision 1114) @@ -0,0 +1,256 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class RoomBuilder + { + private const float roomHeight = 20.0f; + private readonly PolygonMesh mesh; + private OctreeNode octtree; + + public static void BuildRooms(PolygonMesh mesh) + { + var builder = new RoomBuilder(mesh); + builder.BuildRooms(); + } + + private RoomBuilder(PolygonMesh mesh) + { + this.mesh = mesh; + } + + private void BuildRooms() + { + foreach (Polygon floor in mesh.Floors) + mesh.Rooms.Add(CreateRoom(floor, roomHeight)); + + ConnectRooms(); + UpdateRoomsHeight(); + } + + private Room CreateRoom(Polygon floor, float height) + { + var floorPlane = floor.Plane; + + var bbox = floor.BoundingBox; + bbox.Max.Y += height * floorPlane.Normal.Y; + + var room = new Room + { + FloorPolygon = floor, + BoundingBox = bbox, + FloorPlane = floor.Plane, + Height = height * floorPlane.Normal.Y, + BspTree = BuildBspTree(floor, height * floorPlane.Normal.Y) + }; + + if (floor.Material != null) + room.Grid = CreateRoomGrid(floor); + + return room; + } + + private static RoomBspNode BuildBspTree(Polygon floor, float height) + { + var points = floor.Points.ToArray(); + var floorPlane = floor.Plane; + + var bottom = new Plane(-floorPlane.Normal, -floorPlane.D); + var node = new RoomBspNode(bottom, null, null); + + var top = new Plane(floorPlane.Normal, floorPlane.D - height); + node = new RoomBspNode(top, node, null); + + for (int i = 0; i < points.Length; i++) + { + var p0 = points[i]; + var p1 = points[(i + 1) % points.Length]; + var p2 = p1 + Vector3.Up; + + node = new RoomBspNode(new Plane(p0, p1, p2), node, null); + } + + return node; + } + + private static RoomGrid CreateRoomGrid(Polygon floor) + { + if (!File.Exists(floor.Material.ImageFilePath)) + return null; + + var image = TgaReader.Read(floor.Material.ImageFilePath); + var grid = RoomGrid.FromImage(image); + + //BoundingBox bbox = floor.GetBoundingBox(); + + // + // TODO: don't use hardcoded constants + // + + //int gx = (int)(((bbox.Max.X - bbox.Min.X) / 4) + 5); + //int gz = (int)(((bbox.Max.Z - bbox.Min.Z) / 4) + 5); + + //if (gx != image.Width || gz != image.Height) + //{ + // //Console.Error.WriteLine("Warning: Grid {0} has wrong size, expecting {1}x{2}, got {3}x{4}", + // // floor.Material.Name, + // // gx, gz, + // // image.Width, image.Height); + //} + + return grid; + } + + private void ConnectRooms() + { + octtree = OctreeBuilder.BuildRoomsOctree(mesh); + + foreach (Polygon ghost in mesh.Ghosts) + { + float minY = ghost.Points.Select(p => p.Y).Min(); + Vector3[] points = ghost.Points.Where(p => Math.Abs(p.Y - minY) <= 0.1f).ToArray(); + + if (points.Length != 2) + { + Console.Error.WriteLine("BNV Builder: Bad ghost, it must have 2 lowest points, it has {0}, ignoring", points.Length); + continue; + } + + Vector3 mid = (points[0] + points[1]) / 2.0f; + Vector3 normal = ghost.Plane.Normal; + + Vector3 p0 = mid - normal + Vector3.Up * 2.0f; + Vector3 p1 = mid + normal + Vector3.Up * 2.0f; + + RoomPair pair = PairRooms(p0, p1); + + if (pair == null) + { + Console.WriteLine("BNV Builder: Ghost '{0}' has no adjacencies at {1} and {2}, ignoring", ghost.ObjectName, p0, p1); + continue; + } + + if (pair.Room0.IsStairs || pair.Room1.IsStairs) + { + var stairs = pair.Room0; + + if (!stairs.IsStairs) + stairs = pair.Room1; + + ghost.Flags &= ~GunkFlags.Ghost; + + if (ghost.Material != null) + ghost.Material.Flags &= ~GunkFlags.Ghost; + + if (ghost.BoundingBox.Min.Y > stairs.FloorPolygon.BoundingBox.Max.Y - 1.0f) + ghost.Flags |= GunkFlags.StairsDown; + else + ghost.Flags |= GunkFlags.StairsUp; + } + else + { + ghost.Flags |= GunkFlags.Ghost; + } + + pair.Room1.Ajacencies.Add(new RoomAdjacency(pair.Room0, ghost)); + pair.Room0.Ajacencies.Add(new RoomAdjacency(pair.Room1, ghost)); + } + } + + #region private class RoomPair + + private class RoomPair : IComparable + { + public readonly Room Room0; + public readonly Room Room1; + public readonly float HeightDelta; + public readonly float VolumeDelta; + + public RoomPair(Room r0, Vector3 p0, Room r1, Vector3 p1) + { + Room0 = r0; + Room1 = r1; + HeightDelta = r0.FloorPlane.DotCoordinate(p0) - r1.FloorPlane.DotCoordinate(p1); + VolumeDelta = r0.BoundingBox.Volume() - r1.BoundingBox.Volume(); + } + + int IComparable.CompareTo(RoomPair other) + { + if (Math.Abs(HeightDelta - other.HeightDelta) < 1e-5f) + return VolumeDelta.CompareTo(other.VolumeDelta); + else if (HeightDelta < other.HeightDelta) + return -1; + else + return 1; + } + } + + #endregion + + private RoomPair PairRooms(Vector3 p0, Vector3 p1) + { + var pairs = new List(); + + var rooms0 = FindRooms(p0); + var rooms1 = FindRooms(p1); + + foreach (Room r0 in rooms0) + { + foreach (Room r1 in rooms1) + { + if (r0 != r1) + pairs.Add(new RoomPair(r0, p0, r1, p1)); + } + } + + pairs.Sort(); + + return pairs.Count > 0 ? pairs[0] : null; + } + + private List FindRooms(Vector3 point) + { + var rooms = new List(); + + var node = octtree.FindLeaf(point); + + if (node != null) + { + foreach (var room in node.Rooms) + { + if (room.Contains(point)) + rooms.Add(room); + } + } + + return rooms; + } + + /// + /// Set the height of the room to the max height of adjacencies. + /// + private void UpdateRoomsHeight() + { + foreach (var room in mesh.Rooms) + { + float maxFloorY = room.FloorPolygon.Points.Max(p => p.Y); + float maxRoomY; + + if (room.Ajacencies.Count == 0) + maxRoomY = maxFloorY + 20.0f; + else + maxRoomY = room.Ajacencies.Max(a => a.Ghost.Points.Max(p => p.Y)); + + var bbox = room.FloorPolygon.BoundingBox; + bbox.Max.Y = maxRoomY; + + room.BoundingBox = bbox; + room.Height = (maxRoomY - maxFloorY) * room.FloorPlane.Normal.Y; + room.BspTree = BuildBspTree(room.FloorPolygon, room.Height); + } + } + } +} Index: /OniSplit/Akira/RoomDaeReader.cs =================================================================== --- /OniSplit/Akira/RoomDaeReader.cs (revision 1114) +++ /OniSplit/Akira/RoomDaeReader.cs (revision 1114) @@ -0,0 +1,214 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class RoomDaeReader + { + private readonly PolygonMesh mesh; + private readonly List positions; + private readonly Stack nodeTransformStack; + private Dae.Scene scene; + private Matrix nodeTransform; + + public static PolygonMesh Read(Dae.Scene scene) + { + var reader = new RoomDaeReader(); + reader.ReadScene(scene); + return reader.mesh; + } + + private RoomDaeReader() + { + mesh = new PolygonMesh(new MaterialLibrary()); + + positions = mesh.Points; + + nodeTransformStack = new Stack(); + nodeTransform = Matrix.Identity; + } + + private void ReadScene(Dae.Scene scene) + { + this.scene = scene; + + foreach (Dae.Node node in scene.Nodes) + ReadNode(node); + } + + private void ReadNode(Dae.Node node) + { + nodeTransformStack.Push(nodeTransform); + + foreach (var transform in node.Transforms) + nodeTransform = transform.ToMatrix() * nodeTransform; + + foreach (var geometryInstance in node.GeometryInstances) + ReadGeometryInstance(node, geometryInstance); + + foreach (var child in node.Nodes) + ReadNode(child); + + nodeTransform = nodeTransformStack.Pop(); + } + + private void ReadGeometryInstance(Dae.Node node, Dae.GeometryInstance instance) + { + var geometry = instance.Target; + + foreach (var primitives in geometry.Primitives) + { + if (primitives.PrimitiveType != Dae.MeshPrimitiveType.Polygons) + { + Console.Error.WriteLine("Unsupported primitive type '{0}' found in geometry '{1}', ignoring.", primitives.PrimitiveType, geometry.Id); + continue; + } + + ReadPolygonPrimitives(node, primitives, instance.Materials.Find(m => m.Symbol == primitives.MaterialSymbol)); + } + } + + private void ReadPolygonPrimitives(Dae.Node node, Dae.MeshPrimitives primitives, Dae.MaterialInstance materialInstance) + { + var positionInput = primitives.Inputs.FirstOrDefault(i => i.Semantic == Dae.Semantic.Position); + var positionIndices = ReadInputIndexed(positionInput, positions, Dae.Source.ReadVector3); + + foreach (int i in positionIndices) + positions[i] = Vector3.Transform(positions[i], ref nodeTransform); + + int startIndex = 0; + + foreach (int vertexCount in primitives.VertexCounts) + { + var polygon = CreatePolygon(positionIndices, startIndex, vertexCount); + startIndex += vertexCount; + + if (polygon == null) + { + Console.Error.WriteLine("BNV polygon: discarded, polygon is degenerate"); + continue; + } + + polygon.FileName = node.FileName; + polygon.ObjectName = node.Name; + + if (Math.Abs(polygon.Plane.Normal.Y) < 0.0001f) + { + if (polygon.BoundingBox.Height < 1.0f) + { + Console.Error.WriteLine("BNV polygon: discarded, ghost height must be greater than 1, it is {0}", polygon.BoundingBox.Height); + continue; + } + + if (polygon.PointIndices.Length != 4) + { + Console.Error.WriteLine("BNV polygon: discarded, ghost is a {0}-gon", polygon.PointIndices.Length); + continue; + } + + mesh.Ghosts.Add(polygon); + } + else if ((polygon.Flags & GunkFlags.Horizontal) != 0) + { + mesh.Floors.Add(polygon); + } + else + { + Console.Error.WriteLine("BNV polygon: discarded, not a ghost and not a floor"); + } + } + } + + private Polygon CreatePolygon(int[] positionIndices, int startIndex, int vertexCount) + { + int endIndex = startIndex + vertexCount; + + var indices = new List(vertexCount); + + for (int i = startIndex; i < endIndex; i++) + { + int i0 = positionIndices[i == startIndex ? endIndex - 1 : i - 1]; + int i1 = positionIndices[i]; + int i2 = positionIndices[i + 1 == endIndex ? startIndex : i + 1]; + + if (i0 == i1) + { + Console.Error.WriteLine("BNV polygon: discarding degenerate edge {0}", mesh.Points[i1]); + continue; + } + + Vector3 p0 = mesh.Points[i0]; + Vector3 p1 = mesh.Points[i1]; + Vector3 p2 = mesh.Points[i2]; + + Vector3 p1p0 = p1 - p0; + Vector3 p2p1 = p2 - p1; + + //if (p1p0.LengthSquared() < 0.000001f) + //{ + // Console.Error.WriteLine("BNV polygon: merging duplicate points {0} {1}", p0, p1); + // continue; + //} + + if (Vector3.Cross(p2p1, p1p0).LengthSquared() < 0.000001f) + { + //Console.Error.WriteLine("BNV polygon: combining colinear edges at {0}", p1); + continue; + } + + indices.Add(i1); + } + + var indicesArray = indices.ToArray(); + + if (CheckDegenerate(mesh.Points, indicesArray)) + return null; + + return new Polygon(mesh, indicesArray); + } + + private static bool CheckDegenerate(List positions, int[] indices) + { + if (indices.Length < 3) + return true; + + Vector3 p0 = positions[indices[0]]; + Vector3 p1 = positions[indices[1]]; + Vector3 s0, s1, c; + + for (int i = 2; i < indices.Length; i++) + { + Vector3 p2 = positions[indices[i]]; + + Vector3.Substract(ref p0, ref p1, out s0); + Vector3.Substract(ref p2, ref p1, out s1); + Vector3.Cross(ref s0, ref s1, out c); + + if (Math.Abs(c.LengthSquared()) < 0.0001f && Vector3.Dot(ref s0, ref s1) > 0.0f) + return true; + + p0 = p1; + p1 = p2; + } + + return false; + } + + private static int[] ReadInputIndexed(Dae.IndexedInput input, List list, Func elementReader) + where T : struct + { + var indices = new int[input.Indices.Count]; + + for (int i = 0; i < input.Indices.Count; i++) + { + var v = elementReader(input.Source, input.Indices[i]); + indices[i] = list.Count; + list.Add(v); + } + + return indices; + } + } +} Index: /OniSplit/Akira/RoomDaeWriter.cs =================================================================== --- /OniSplit/Akira/RoomDaeWriter.cs (revision 1114) +++ /OniSplit/Akira/RoomDaeWriter.cs (revision 1114) @@ -0,0 +1,376 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using Oni.Collections; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class RoomDaeWriter + { + #region Private data + private readonly PolygonMesh source; + private DaeSceneBuilder world; + + 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; + this.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 polygons = new List(); + private readonly List points = new List(); + private readonly Dictionary uniquePoints = new Dictionary(); + private readonly List texCoords = new List(); + private readonly Dictionary uniqueTexCoords = new Dictionary(); + private readonly List colors = new List(); + private readonly Dictionary uniqueColors = new Dictionary(); + 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 + // + + Vector3 center = BoundingSphere.CreateFromPoints(points).Center; + + BoundingBox bbox = BoundingBox.CreateFromPoints(points); + center.Y = bbox.Min.Y; + + translation = center; + + for (int i = 0; i < points.Count; i++) + points[i] -= center; + } + + public void AddPolygon(Polygon polygon) + { + polygons.Add(new DaePolygon( + polygon, + Remap(polygon.Mesh.Points, polygon.PointIndices, points, uniquePoints), + null, + null)); + } + + public IEnumerable Polygons => from p in polygons + where p.Source != null + select p.Source; + + private static int[] Remap(IList values, int[] indices, List list, Dictionary 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(IList values, List list, Dictionary 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(List list, Dictionary 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() + { + var positionSource = new Dae.Source(points); + var primitives = new Dae.MeshPrimitives(Dae.MeshPrimitiveType.Polygons); + var posInput = new Dae.IndexedInput(Dae.Semantic.Position, positionSource); + + primitives.Inputs.Add(posInput); + + foreach (var poly in polygons) + { + primitives.VertexCounts.Add(poly.PointIndices.Length); + + posInput.Indices.AddRange(poly.PointIndices); + } + + geometry = new Dae.Geometry + { + Name = Name + "_geo", + Vertices = { new Dae.Input(Dae.Semantic.Position, positionSource) }, + Primitives = { primitives } + }; + } + + public Dae.Geometry Geometry + { + get + { + return geometry; + } + } + } + + #endregion + #region private class DaeSceneBuilder + + private class DaeSceneBuilder + { + private readonly Dae.Scene scene; + private readonly Dictionary nameMeshBuilder; + private readonly List meshBuilders; + private readonly Dictionary materials; + private string imagesFolder = "images"; + + public DaeSceneBuilder() + { + scene = new Dae.Scene(); + nameMeshBuilder = new Dictionary(StringComparer.Ordinal); + meshBuilders = new List(); + materials = new Dictionary(); + } + + 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 MeshBuilders + { + get { return 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 inst = new Dae.GeometryInstance(meshBuilder.Geometry); + + var node = new Dae.Node(); + node.Name = meshBuilder.Name; + node.Instances.Add(inst); + + if (meshBuilder.Translation != Vector3.Zero) + node.Transforms.Add(new Dae.TransformTranslate(meshBuilder.Translation)); + + scene.Nodes.Add(node); + } + } + + private void BuildMaterials() + { + foreach (KeyValuePair pair in materials) + { + var material = pair.Key; + + var image = new Dae.Image + { + FilePath = "./" + GetImageFileName(material).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) + } + }; + + var daeMaterial = pair.Value; + daeMaterial.Name = material.Name; + daeMaterial.Effect = effect; + } + } + + private string GetImageFileName(Material material) + { + if (material.IsMarker) + return Path.Combine("markers", material.Name + ".tga"); + + return Path.Combine(imagesFolder, material.Name + ".tga"); + } + + 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 Write(PolygonMesh mesh, string filePath) + { + var writer = new RoomDaeWriter(mesh); + writer.WriteGeometry(); + writer.world.Write(filePath); + } + + private RoomDaeWriter(PolygonMesh source) + { + this.source = source; + } + + private void WriteGeometry() + { + world = new DaeSceneBuilder(); + + for (int i = 0; i < source.Polygons.Count; i++) + { + var polygon = source.Polygons[i]; + + var name = string.Format(CultureInfo.InvariantCulture, "floor_{0}", i); + var meshBuilder = world.GetMeshBuilder(name); + meshBuilder.AddPolygon(polygon); + } + + foreach (var meshBuilder in world.MeshBuilders) + { + meshBuilder.ResetTransform(); + } + + world.Build(); + } + } +} Index: /OniSplit/Akira/RoomExtractor.cs =================================================================== --- /OniSplit/Akira/RoomExtractor.cs (revision 1114) +++ /OniSplit/Akira/RoomExtractor.cs (revision 1114) @@ -0,0 +1,128 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Oni.Akira +{ + internal class RoomExtractor + { + private readonly IEnumerable fromFiles; + private readonly string outputFilePath; + + private PolygonMesh mesh; + private List positions; + private Stack nodeTransformStack; + private Matrix nodeTransform; + private string nodeName; + + public RoomExtractor(IEnumerable fromFiles, string outputFilePath) + { + this.fromFiles = fromFiles; + this.outputFilePath = outputFilePath; + } + + public void Extract() + { + mesh = new PolygonMesh(new MaterialLibrary()); + + positions = mesh.Points; + + nodeTransformStack = new Stack(); + nodeTransform = Matrix.Identity; + + foreach (var filePath in fromFiles) + ReadScene(Dae.Reader.ReadFile(filePath)); + + var q = new PolygonQuadrangulate(mesh); + q.Execute(); + + RoomDaeWriter.Write(mesh, outputFilePath); + } + + private void ReadScene(Dae.Scene scene) + { + foreach (var node in scene.Nodes) + ReadNode(node); + } + + private void ReadNode(Dae.Node node) + { + nodeTransformStack.Push(nodeTransform); + + foreach (var transform in node.Transforms) + nodeTransform = transform.ToMatrix() * nodeTransform; + + nodeName = node.Name; + + foreach (var geometryInstance in node.GeometryInstances) + ReadGeometryInstance(geometryInstance); + + foreach (var child in node.Nodes) + ReadNode(child); + + nodeTransform = nodeTransformStack.Pop(); + } + + private void ReadGeometryInstance(Dae.GeometryInstance instance) + { + foreach (var primitives in instance.Target.Primitives) + { + if (primitives.PrimitiveType != Dae.MeshPrimitiveType.Polygons) + { + Console.Error.WriteLine("Unsupported primitive type '{0}' found in geometry '{1}', ignoring.", primitives.PrimitiveType, instance.Name); + continue; + } + + ReadPolygonPrimitives(primitives, instance.Materials.Find(m => m.Symbol == primitives.MaterialSymbol)); + } + } + + private void ReadPolygonPrimitives(Dae.MeshPrimitives primitives, Dae.MaterialInstance materialInstance) + { + int[] positionIndices = null; + + foreach (var input in primitives.Inputs) + { + switch (input.Semantic) + { + case Dae.Semantic.Position: + positionIndices = ReadInputIndexed(input, positions, Dae.Source.ReadVector3); + break; + } + } + + foreach (int i in positionIndices) + positions[i] = Vector3.Transform(positions[i], ref nodeTransform); + + int startIndex = 0; + + foreach (int vertexCount in primitives.VertexCounts) + { + var polygonPointIndices = new int[vertexCount]; + Array.Copy(positionIndices, startIndex, polygonPointIndices, 0, vertexCount); + + var polygon = new Polygon(mesh, polygonPointIndices); + + if (Vector3.Dot(polygon.Plane.Normal, Vector3.UnitY) >= 0.3420201f) + mesh.Polygons.Add(polygon); + + startIndex += vertexCount; + } + } + + private static int[] ReadInputIndexed(Dae.IndexedInput input, List list, Func elementReader) + where T : struct + { + var indices = new int[input.Indices.Count]; + + for (int i = 0; i < input.Indices.Count; i++) + { + var v = elementReader(input.Source, input.Indices[i]); + indices[i] = list.Count; + list.Add(v); + } + + return indices; + } + } +} Index: /OniSplit/Akira/RoomFlags.cs =================================================================== --- /OniSplit/Akira/RoomFlags.cs (revision 1114) +++ /OniSplit/Akira/RoomFlags.cs (revision 1114) @@ -0,0 +1,13 @@ +using System; + +namespace Oni.Akira +{ + [Flags] + internal enum RoomFlags + { + None = 0x00, + Stairs = 0x01, + Room = 0x04, + Simple = 0x10 + } +} Index: /OniSplit/Akira/RoomGrid.cs =================================================================== --- /OniSplit/Akira/RoomGrid.cs (revision 1114) +++ /OniSplit/Akira/RoomGrid.cs (revision 1114) @@ -0,0 +1,136 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class RoomGrid + { + #region Private data + private static readonly Color[] gridColors = new[] + { + new Color(255, 255, 255), + new Color(0x90, 0xee, 0x90), + new Color(0xad, 0xd8, 0xe6), + new Color(0x87, 0xce, 0xfa), + new Color(0, 255, 0), + new Color(0, 0, 255), + new Color(0, 0, 128), + new Color(0, 128, 0), + new Color(255, 165, 0), + new Color(255, 0, 0) + }; + + private const int origin = -2; + private const float tileSize = 4.0f; + private readonly int xOrigin = -2; + private readonly int xTiles; + private readonly int zOrigin = -2; + private readonly int zTiles; + private readonly byte[] data; + private readonly byte[] debugData; + #endregion + + public RoomGrid(int xTiles, int zTiles, byte[] data, byte[] debugData) + { + this.xTiles = xTiles; + this.zTiles = zTiles; + this.data = data; + this.debugData = debugData; + } + + public static RoomGrid FromImage(Surface image) + { + var data = new byte[image.Width * image.Height]; + + for (int z = 0; z < image.Height; z++) + { + for (int x = 0; x < image.Width; x++) + { + int type = Array.IndexOf(gridColors, image[x, z]); + + if (type == -1) + throw new InvalidDataException(string.Format("Color '{0}' does not match a valid tile type", image[x, z])); + + data[z * image.Width + x] = (byte)type; + } + } + + return new RoomGrid(image.Width, image.Height, data, null); + } + + public static RoomGrid FromCompressedData(int xTiles, int zTiles, byte[] compressedData) + { + var data = new byte[xTiles * zTiles]; + + if (compressedData != null) + { + int k = 0; + + for (int i = 0; i < compressedData.Length;) + { + byte run = compressedData[i++]; + byte type = (byte)(run & 0x0f); + byte count = (byte)(run >> 4); + + if (count == 0) + count = compressedData[i++]; + + for (int j = 0; j < count; j++) + data[k++] = type; + } + } + + return new RoomGrid(xTiles, zTiles, data, null); + } + + public int XTiles => xTiles; + public int ZTiles => zTiles; + public float TileSize => tileSize; + public int XOrigin => xOrigin; + public int ZOrigin => zOrigin; + public byte[] DebugData => debugData; + + public byte[] Compress() + { + var compressed = new List(data.Length); + + for (int i = 0; i < data.Length;) + { + byte type = data[i]; + int count = 1; + + while (count < 255 && i + count < data.Length && data[i + count] == type) + count++; + + if (count < 16) + { + compressed.Add((byte)((count << 4) | type)); + } + else + { + compressed.Add(type); + compressed.Add((byte)count); + } + + i += count; + } + + return compressed.ToArray(); + } + + public Surface ToImage() + { + var image = new Surface(xTiles, zTiles, SurfaceFormat.BGRX); + + for (int z = 0; z < zTiles; z++) + { + for (int x = 0; x < xTiles; x++) + image[x, z] = gridColors[data[z * xTiles + x]]; + } + + return image; + } + } +} Index: /OniSplit/Akira/RoomGridBuilder.cs =================================================================== --- /OniSplit/Akira/RoomGridBuilder.cs (revision 1114) +++ /OniSplit/Akira/RoomGridBuilder.cs (revision 1114) @@ -0,0 +1,244 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Oni.Collections; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class RoomGridBuilder + { + private readonly Dae.Scene roomsScene; + private readonly PolygonMesh geometryMesh; + private PolygonMesh roomsMesh; + private OctreeNode geometryOcttree; + private OctreeNode dangerOcttree; + + public RoomGridBuilder(Dae.Scene roomsScene, PolygonMesh geometryMesh) + { + this.roomsScene = roomsScene; + this.geometryMesh = geometryMesh; + } + + public PolygonMesh Mesh => roomsMesh; + + public void Build() + { + roomsMesh = RoomDaeReader.Read(roomsScene); + + RoomBuilder.BuildRooms(roomsMesh); + + Console.Error.WriteLine("Read {0} rooms", roomsMesh.Rooms.Count); + + geometryOcttree = OctreeBuilder.Build(geometryMesh, GunkFlags.NoCollision | GunkFlags.NoCharacterCollision); + dangerOcttree = OctreeBuilder.Build(geometryMesh, p => (p.Flags & GunkFlags.Danger) != 0); + + ProcessStairsCollision(); + + Parallel.ForEach(roomsMesh.Rooms, room => + { + BuildGrid(room); + }); + } + + private void ProcessStairsCollision() + { + var verticalTolerance1 = new Vector3(0.0f, 0.1f, 0.0f); + var verticalTolerance2 = new Vector3(0.0f, 7.5f, 0.0f); + + foreach (var stairs in geometryMesh.Polygons.Where(p => p.IsStairs && p.VertexCount == 4)) + { + var floorPoints = stairs.Points.Select(v => v + verticalTolerance1).ToArray(); + var ceilPoints = stairs.Points.Select(v => v + verticalTolerance2).ToArray(); + var bbox = BoundingBox.CreateFromPoints(floorPoints.Concatenate(ceilPoints)); + + var floorPlane = new Plane(floorPoints[0], floorPoints[1], floorPoints[2]); + var ceilingPlane = new Plane(ceilPoints[0], ceilPoints[1], ceilPoints[2]); + + foreach (var node in geometryOcttree.FindLeafs(bbox)) + { + foreach (var poly in node.Polygons) + { + if ((poly.Flags & (GunkFlags.NoCollision | GunkFlags.NoCharacterCollision)) != 0) + { + // + // already a no collision polygon, skip it + // + + continue; + } + + if (!poly.BoundingBox.Intersects(bbox)) + continue; + + var points = poly.Points.ToList(); + + points = PolygonUtils.ClipToPlane(points, floorPlane); + + if (points == null) + { + // + // this polygon is below stairs, skip it + // + + continue; + } + + points = PolygonUtils.ClipToPlane(points, ceilingPlane); + + if (points != null) + { + // + // this polygon is too high above the stairs, skip it + // + + continue; + } + + poly.Flags |= GunkFlags.NoCharacterCollision; + } + } + } + } + + private void BuildGrid(Room room) + { + var floor = room.FloorPolygon; + var bbox = room.BoundingBox; + + // + // Create an empty grid and mark all tiles as 'danger' + // + + var rasterizer = new RoomGridRasterizer(bbox); + rasterizer.Clear(RoomGridWeight.Danger); + + // + // Collect all polygons that intersect the room + // + + bbox.Inflate(2.0f * new Vector3(rasterizer.TileSize, 0.0f, rasterizer.TileSize)); + + var testbox = bbox; + testbox.Min.X -= 1.0f; + testbox.Min.Y = bbox.Min.Y - 6.0f; + testbox.Min.Z -= 1.0f; + testbox.Max.X += 1.0f; + testbox.Max.Y = bbox.Max.Y - 6.0f; + testbox.Max.Z += 1.0f; + + var polygons = new Set(); + var dangerPolygons = new Set(); + + foreach (var node in geometryOcttree.FindLeafs(testbox)) + { + polygons.UnionWith(node.Polygons); + } + + foreach (var node in dangerOcttree.FindLeafs(testbox)) + { + dangerPolygons.UnionWith(node.Polygons); + } + + // + // Draw all the floors on the grid. This will overwrite the 'danger' + // areas with 'clear' areas. This means danger area will remain + // where there isn't any floor. + // + + foreach (var polygon in polygons) + { + if (polygon.Plane.Normal.Y > 0.5f) + rasterizer.DrawFloor(polygon.Points); + } + + if (room.FloorPlane.Normal.Y >= 0.999f) + { + // + // Draw the walls. + // + + float floorMaxY = floor.BoundingBox.Max.Y; + var floorPlane = new Plane(floor.Plane.Normal, floor.Plane.D - 4.0f); + var ceilingPlane = new Plane(-floor.Plane.Normal, -(floor.Plane.D - 20.0f)); + + foreach (var polygon in polygons) + { + if ((polygon.Flags & (GunkFlags.Stairs | GunkFlags.NoCharacterCollision | GunkFlags.Impassable)) == 0) + { + // + // Remove curbs from character collision. + // + + var polyBox = polygon.BoundingBox; + + if (Math.Abs(polygon.Plane.Normal.Y) < MathHelper.Eps + && polyBox.Height <= 4.0f + && Math.Abs(polyBox.Max.Y - floorMaxY) <= 4.0f) + { + polygon.Flags |= GunkFlags.NoCharacterCollision; + continue; + } + } + + if ((polygon.Flags & (GunkFlags.Stairs | GunkFlags.GridIgnore | GunkFlags.NoCollision | GunkFlags.NoCharacterCollision)) != 0) + continue; + + var points = polygon.Points.ToList(); + + points = PolygonUtils.ClipToPlane(points, floorPlane); + + if (points == null) + continue; + + points = PolygonUtils.ClipToPlane(points, ceilingPlane); + + if (points == null) + continue; + + if (Math.Abs(polygon.Plane.Normal.Y) <= 0.1f) + rasterizer.DrawWall(points); + else + rasterizer.DrawImpassable(points); + } + + // + // Draw ramp entry/exit lines. Hmm, this seems useless. + // + + //if (room.FloorPlane.Normal.Y >= 0.98f) + //{ + // foreach (RoomAdjacency adj in room.Ajacencies) + // { + // if (Math.Abs(room.FloorPlane.Normal.Y - adj.AdjacentRoom.FloorPlane.Normal.Y) > 0.001f) + // rasterizer.DrawStairsEntry(adj.Ghost.Points); + // } + //} + + // + // Draw 'danger' quads. + // + + foreach (var polygon in dangerPolygons) + { + rasterizer.DrawDanger(polygon.Points); + } + + // + // Draw 'near wall' borders. + // + + rasterizer.AddBorders(); + } + + // + // Finally, get the rasterized pathfinding grid. + // + + room.Grid = rasterizer.GetGrid(); + + if (room.Grid.XTiles * room.Grid.ZTiles > 256 * 256) + Console.Error.WriteLine("Warning: pathfinding grid too large"); + } + } +} Index: /OniSplit/Akira/RoomGridRasterizer.cs =================================================================== --- /OniSplit/Akira/RoomGridRasterizer.cs (revision 1114) +++ /OniSplit/Akira/RoomGridRasterizer.cs (revision 1114) @@ -0,0 +1,428 @@ +using System; +using System.IO; +using System.Collections.Generic; +using Oni.Imaging; + +namespace Oni.Akira +{ + internal class RoomGridRasterizer + { + private const int origin = -2; + private const float tileSize = 4.0f; + private const int margin = 3; + private readonly int xTiles; + private readonly int zTiles; + private readonly byte[] data; + private readonly Vector3 worldOrigin; + //private readonly List debugData; + + private enum RoomGridDebugType : byte + { + None, + SlopedQuad, + StairQuad, + Wall, + DangerQuad, + ImpassableQuad, + Floor + } + + //private class RoomGridDebugData + //{ + // public int quadIndex; + // public RoomGridDebugType type; + // public RoomGridWeight weight; + // public short x, y; + //} + + public RoomGridRasterizer(BoundingBox bbox) + { + this.xTiles = (int)(((bbox.Max.X - bbox.Min.X) / tileSize) + (-origin * 2) + 1) + margin * 2; + this.zTiles = (int)(((bbox.Max.Z - bbox.Min.Z) / tileSize) + (-origin * 2) + 1) + margin * 2; + this.data = new byte[xTiles * zTiles]; + this.worldOrigin = bbox.Min; + //this.debugData = new List(); + } + + public void Clear(RoomGridWeight weight) + { + for (int i = 0; i < xTiles * zTiles; i++) + data[i] = (byte)weight; + } + + public int XTiles => xTiles; + public int ZTiles => ZTiles; + + public float TileSize => tileSize; + + public RoomGridWeight this[int x, int z] + { + get { return (RoomGridWeight)data[x + z * xTiles]; } + set { data[x + z * xTiles] = (byte)value; } + } + + public void DrawFloor(IEnumerable points) + { + foreach (var point in ScanPolygon(points.Select(v => WorldToGrid(v)).ToList())) + this[point.X, point.Y] = RoomGridWeight.Clear; + } + + public void DrawDanger(IEnumerable points) + { + foreach (var point in ScanPolygon(points.Select(v => WorldToGrid(v)).ToList())) + this[point.X, point.Y] = RoomGridWeight.Danger; + } + + public void DrawStairsEntry(IEnumerable points) + { + var v0 = points.First(); + var v1 = v0; + + foreach (var v in points) + { + if (v.X < v0.X || (v.X == v0.X && v.Z < v0.Z)) + v0 = v; + + if (v.X > v1.X || (v.X == v1.X && v.Z > v1.Z)) + v1 = v; + } + + Point p0 = WorldToGrid(v0); + Point p1 = WorldToGrid(v1); + + DrawLine(p0, p1, RoomGridWeight.Stairs); + + DrawLine(p0 - Point.UnitY, p1 - Point.UnitY, RoomGridWeight.Clear); + DrawLine(p0 + Point.UnitY, p1 + Point.UnitY, RoomGridWeight.Clear); + DrawLine(p0 + Point.UnitX, p1 + Point.UnitX, RoomGridWeight.Clear); + DrawLine(p0 - Point.UnitX, p1 - Point.UnitX, RoomGridWeight.Clear); + + var pp = points.ToArray(); + Array.Sort(pp, (x, y) => x.Y.CompareTo(y.Y)); + DrawImpassable(pp[0]); + DrawImpassable(pp[1]); + } + + public void DrawWall(IEnumerable points) + { + var v0 = points.First(); + var v1 = v0; + + foreach (var v in points) + { + if (v.X < v0.X || (v.X == v0.X && v.Z < v0.Z)) + v0 = v; + + if (v.X > v1.X || (v.X == v1.X && v.Z > v1.Z)) + v1 = v; + } + + Point p0 = WorldToGrid(v0); + Point p1 = WorldToGrid(v1); + + DrawLine(p0, p1, RoomGridWeight.Impassable); + + DrawLine(p0 - Point.UnitY, p1 - Point.UnitY, RoomGridWeight.SemiPassable); + DrawLine(p0 + Point.UnitY, p1 + Point.UnitY, RoomGridWeight.SemiPassable); + DrawLine(p0 + Point.UnitX, p1 + Point.UnitX, RoomGridWeight.SemiPassable); + DrawLine(p0 - Point.UnitX, p1 - Point.UnitX, RoomGridWeight.SemiPassable); + } + + private void DrawLine(Point p0, Point p1, RoomGridWeight weight) + { + foreach (Point p in ScanLine(p0, p1)) + { + if (weight > this[p.X, p.Y]) + { + this[p.X, p.Y] = weight; + + //debugData.Add(new RoomGridDebugData { + // x = (short)p.X, + // y = (short)p.Y, + // weight = weight + //}); + } + } + } + + private void FillPolygon(IEnumerable points, RoomGridWeight weight) + { + foreach (var point in ScanPolygon(points.Select(v => WorldToGrid(v)).ToList())) + { + if (weight > this[point.X, point.Y]) + this[point.X, point.Y] = weight; + } + } + + public void DrawImpassable(IEnumerable points) + { + FillPolygon(points, RoomGridWeight.Impassable); + } + + public void DrawImpassable(Vector3 position) + { + var point = WorldToGrid(position); + int x = point.X; + int y = point.Y; + + DrawTile(x, y, RoomGridWeight.Impassable); + + DrawTile(x - 1, y, RoomGridWeight.SemiPassable); + DrawTile(x + 1, y, RoomGridWeight.SemiPassable); + DrawTile(x, y - 1, RoomGridWeight.SemiPassable); + DrawTile(x, y + 1, RoomGridWeight.SemiPassable); + DrawTile(x - 1, y - 1, RoomGridWeight.SemiPassable); + DrawTile(x + 1, y - 1, RoomGridWeight.SemiPassable); + DrawTile(x + 1, y + 1, RoomGridWeight.SemiPassable); + DrawTile(x - 1, y + 1, RoomGridWeight.SemiPassable); + } + + private void DrawTile(int x, int y, RoomGridWeight weight) + { + if (0 <= x && x < xTiles && 0 <= y && y < zTiles) + { + if (weight > this[x, y]) + this[x, y] = weight; + } + } + + public void AddBorders() + { + AddBorder(RoomGridWeight.Danger, RoomGridWeight.Clear, RoomGridWeight.Border4); + AddBorder(RoomGridWeight.Border4, RoomGridWeight.Clear, RoomGridWeight.Border3); + AddBorder(RoomGridWeight.Border3, RoomGridWeight.Clear, RoomGridWeight.Border2); + AddBorder(RoomGridWeight.Border2, RoomGridWeight.Clear, RoomGridWeight.Border1); + AddBorder(RoomGridWeight.SemiPassable, RoomGridWeight.Clear, RoomGridWeight.NearWall); + } + + private void AddBorder(RoomGridWeight aroundOf, RoomGridWeight onlyIf, RoomGridWeight border) + { + for (int z = 0; z < zTiles; z++) + { + for (int x = 0; x < xTiles; x++) + { + if (this[x, z] != aroundOf) + continue; + + if (x - 1 >= 0 && this[x - 1, z] == onlyIf) + this[x - 1, z] = border; + + if (x + 1 < xTiles && this[x + 1, z] == onlyIf) + this[x + 1, z] = border; + + if (z - 1 >= 0 && this[x, z - 1] == onlyIf) + this[x, z - 1] = border; + + if (z + 1 < zTiles && this[x, z + 1] == onlyIf) + this[x, z + 1] = border; + } + } + } + + private Point WorldToGrid(Vector3 world) + { + return new Point( + FMath.TruncateToInt32((world.X - worldOrigin.X) / tileSize) - origin + margin, + FMath.TruncateToInt32((world.Z - worldOrigin.Z) / tileSize) - origin + margin); + } + + public RoomGrid GetGrid() + { + int gridXTiles = xTiles - 2 * margin; + int gridZTiles = zTiles - 2 * margin; + + var gridData = new byte[gridXTiles * gridZTiles]; + + for (int z = margin; z < zTiles - margin; z++) + { + for (int x = margin; x < xTiles - margin; x++) + gridData[(x - margin) + (z - margin) * gridXTiles] = data[x + z * xTiles]; + } + + //var debugStream = new MemoryStream(debugData.Count * 16); + + //using (var writer = new BinaryWriter(debugStream)) + //{ + // foreach (var data in debugData) + // { + // writer.WriteByte((byte)data.type); + // writer.WriteByte(0); + // writer.Write(data.x); + // writer.Write(data.y); + // writer.WriteInt16(0); + // writer.Write(data.quadIndex); + // writer.Write((int)data.weight); + // } + //} + + return new RoomGrid(gridXTiles, gridZTiles, gridData, null); + } + + private IEnumerable ScanLine(Point p0, Point p1) + { + return ScanLine(p0.X, p0.Y, p1.X, p1.Y); + } + + private IEnumerable ScanLine(int x0, int y0, int x1, int y1) + { + int dx = (x0 < x1) ? x1 - x0 : x0 - x1; + int dy = (y0 < y1) ? y1 - y0 : y0 - y1; + int sx = (x0 < x1) ? 1 : -1; + int sy = (y0 < y1) ? 1 : -1; + int err = dx - dy; + + while (true) + { + if (0 <= x0 && x0 < xTiles && 0 <= y0 && y0 < zTiles) + yield return new Point(x0, y0); + + if (x0 == x1 && y0 == y1) + break; + + int derr = 2 * err; + + if (derr > -dy) + { + err = err - dy; + x0 = x0 + sx; + } + + if (derr < dx) + { + err = err + dx; + y0 = y0 + sy; + } + } + } + + private IEnumerable ScanLine(Vector2 p0, Vector2 p1) + { + return ScanLine(p0.X, p0.Y, p1.X, p1.Y); + } + + private IEnumerable ScanLine(float x0, float y0, float x1, float y1) + { + float dx = (x0 < x1) ? x1 - x0 : x0 - x1; + float dy = (y0 < y1) ? y1 - y0 : y0 - y1; + float sx = (x0 < x1) ? 1 : -1; + float sy = (y0 < y1) ? 1 : -1; + float err = dx - dy; + + while (true) + { + if (0 <= x0 && x0 < xTiles && 0 <= y0 && y0 < zTiles) + yield return new Vector2(x0, y0); + + if (x0 == x1 && y0 == y1) + break; + + float derr = 2 * err; + + if (derr > -dy) + { + err = err - dy; + x0 = x0 + sx; + } + + if (derr < dx) + { + err = err + dx; + y0 = y0 + sy; + } + } + } + + private IEnumerable ScanPolygon(IList points) + { + var activeEdgeList = new List(); + var activeEdgeTable = new List>(); + int minY = BuildActiveEdgeTable(points, activeEdgeTable); + + for (int y = 0; y < activeEdgeTable.Count; y++) + { + for (int i = 0; i < activeEdgeTable[y].Count; i++) + activeEdgeList.Add(activeEdgeTable[y][i]); + + for (int i = 0; i < activeEdgeList.Count; i++) + { + if (activeEdgeList[i].maxY <= y + minY) + { + activeEdgeList.RemoveAt(i); + i--; + } + } + + activeEdgeList.Sort((a, b) => (a.currentX == b.currentX ? a.slopeRecip.CompareTo(b.slopeRecip) : a.currentX.CompareTo(b.currentX))); + + for (int i = 0; i < activeEdgeList.Count; i += 2) + { + int yLine = minY + y; + + if (0 <= yLine && yLine < zTiles) + { + int xStart = Math.Max(0, (int)Math.Ceiling(activeEdgeList[i].currentX)); + int xEnd = Math.Min(xTiles - 1, (int)activeEdgeList[i + 1].currentX); + + for (int x = xStart; x <= xEnd; x++) + yield return new Point(x, yLine); + } + } + + for (int i = 0; i < activeEdgeList.Count; i++) + activeEdgeList[i].Next(); + } + } + + private class Edge + { + public float maxY; + public float currentX; + public float slopeRecip; + + public Edge(Point current, Point next) + { + maxY = Math.Max(current.Y, next.Y); + slopeRecip = (current.X - next.X) / (float)(current.Y - next.Y); + + if (current.Y == maxY) + currentX = next.X; + else + currentX = current.X; + } + + public void Next() + { + currentX += slopeRecip; + } + } + + private static int BuildActiveEdgeTable(IList points, List> activeEdgeTable) + { + activeEdgeTable.Clear(); + + int minY = points.Min(p => p.Y); + int maxY = points.Max(p => p.Y); + + for (int i = minY; i <= maxY; i++) + activeEdgeTable.Add(new List()); + + for (int i = 0; i < points.Count; i++) + { + Point current = points[i]; + Point next = points[(i + 1) % points.Count]; + + if (current.Y == next.Y) + continue; + + var e = new Edge(current, next); + + if (current.Y == e.maxY) + activeEdgeTable[next.Y - minY].Add(e); + else + activeEdgeTable[current.Y - minY].Add(e); + } + + return minY; + } + } +} Index: /OniSplit/Akira/RoomGridWeight.cs =================================================================== --- /OniSplit/Akira/RoomGridWeight.cs (revision 1114) +++ /OniSplit/Akira/RoomGridWeight.cs (revision 1114) @@ -0,0 +1,18 @@ +using System; + +namespace Oni.Akira +{ + internal enum RoomGridWeight : byte + { + Clear, + NearWall, + Border1, + Border2, + SemiPassable, + Border3, + Border4, + Stairs, + Danger, + Impassable + } +} Index: /OniSplit/BinImporter.cs =================================================================== --- /OniSplit/BinImporter.cs (revision 1114) +++ /OniSplit/BinImporter.cs (revision 1114) @@ -0,0 +1,37 @@ +using System; +using System.IO; +using Oni.Metadata; + +namespace Oni +{ + internal class BinImporter : Importer + { + public override void Import(string filePath, string outputDirPath) + { + using (var reader = new BinaryReader(filePath)) + { + int tag = reader.ReadInt32(); + + if (!Enum.IsDefined(typeof(BinaryTag), tag)) + throw new NotSupportedException(string.Format(".bin file with tag '{0:x}' is unuspported", tag)); + + var tagName = ((BinaryTag)tag).ToString(); + + BeginImport(); + + var bina = CreateInstance(TemplateTag.BINA, tagName + Path.GetFileNameWithoutExtension(filePath)); + + using (var writer = bina.OpenWrite()) + { + writer.Write(reader.Length); + writer.Write(32); + } + + RawWriter.Write(tag); + RawWriter.Write(reader.ReadBytes(reader.Length - 4)); + + Write(outputDirPath); + } + } + } +} Index: /OniSplit/BinaryReader.cs =================================================================== --- /OniSplit/BinaryReader.cs (revision 1114) +++ /OniSplit/BinaryReader.cs (revision 1114) @@ -0,0 +1,438 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using Oni.Imaging; + +namespace Oni +{ + internal sealed class BinaryReader : IDisposable + { + #region Private data + private static readonly byte[] seekBuffer = new byte[512]; + private static readonly Encoding encoding = Encoding.UTF8; + private const float rotationAngleScale = MathHelper.Pi / 32767.5f; + + private FileStream stream; + private byte[] buffer; + private bool bigEndian; + private InstanceFile instanceFile; + #endregion + + public BinaryReader(string filePath) + { + this.buffer = new byte[8]; + this.stream = File.OpenRead(filePath); + } + + public BinaryReader(string filePath, bool bigEndian) + : this(filePath) + { + this.bigEndian = bigEndian; + } + + public BinaryReader(string filePath, InstanceFile instanceFile) + : this(filePath) + { + this.instanceFile = instanceFile; + } + + public void Dispose() + { + if (stream != null) + stream.Dispose(); + + stream = null; + buffer = null; + } + + public string Name => stream.Name; + + public int Length => (int)stream.Length; + + public int Position + { + get + { + return (int)stream.Position; + } + set + { + int currentPosition = (int)stream.Position; + int delta = value - currentPosition; + + if (delta == 0) + return; + + if (delta > 0 && delta <= seekBuffer.Length) + stream.Read(seekBuffer, 0, delta); + else + stream.Position = value; + } + } + + public void Skip(int length) + { + Position += length; + } + + public void SkipCString() + { + for (int b = 1; b != 0 && b != -1; b = stream.ReadByte()) + ; + } + + public int Read(byte[] buffer, int offset, int length) + { + return stream.Read(buffer, offset, length); + } + + public byte[] ReadBytes(int length) + { + var buffer = new byte[length]; + int offset = 0; + + while (length > 0) + { + int read = stream.Read(buffer, offset, length); + + if (read == 0) + break; + + offset += read; + length -= read; + } + + if (offset != buffer.Length) + { + var result = new byte[offset]; + Buffer.BlockCopy(buffer, 0, result, 0, offset); + buffer = result; + } + + return buffer; + } + + public byte ReadByte() + { + int value = stream.ReadByte(); + + if (value == -1) + throw new EndOfStreamException(); + + return (byte)value; + } + + public bool ReadBoolean() + { + return (ReadByte() != 0); + } + + public ushort ReadUInt16() + { + FillBuffer(2); + + if (bigEndian) + { + return (ushort)(buffer[1] | buffer[0] << 8); + } + + return (ushort)(buffer[0] | buffer[1] << 8); + } + + public ushort[] ReadUInt16Array(int length) + { + var array = new ushort[length]; + + for (int i = 0; i < array.Length; i++) + array[i] = ReadUInt16(); + + return array; + } + + public uint ReadUInt32() + { + FillBuffer(4); + + if (bigEndian) + { + return (uint)(buffer[3] | buffer[2] << 8 | buffer[1] << 16 | buffer[0] << 24); + } + + return (uint)(buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24); + } + + public ulong ReadUInt64() + { + FillBuffer(8); + + ulong lo, hi; + + if (bigEndian) + { + hi = (uint)(buffer[3] | buffer[2] << 8 | buffer[1] << 16 | buffer[0] << 24); + lo = (uint)(buffer[7] | buffer[6] << 8 | buffer[5] << 16 | buffer[4] << 24); + } + else + { + lo = (uint)(buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24); + hi = (uint)(buffer[4] | buffer[5] << 8 | buffer[6] << 16 | buffer[7] << 24); + } + + return (hi << 32) | lo; + } + + public short ReadInt16() + { + return (short)ReadUInt16(); + } + + public short[] ReadInt16Array(int length) + { + var array = new short[length]; + + for (int i = 0; i < array.Length; i++) + array[i] = ReadInt16(); + + return array; + } + + public int ReadInt32() + { + return (int)ReadUInt32(); + } + + public int[] ReadInt32VarArray() + { + return ReadInt32Array(ReadInt32()); + } + + public int[] ReadInt32Array(int length) + { + var array = new int[length]; + + for (int i = 0; i < array.Length; i++) + array[i] = ReadInt32(); + + return array; + } + + public long ReadInt64() + { + return (long)ReadUInt64(); + } + + public unsafe float ReadSingle() + { + uint value = ReadUInt32(); + return *((float*)&value); + } + + public float[] ReadSingleArray(int length) + { + var data = new float[length]; + + for (int i = 0; i < data.Length; i++) + data[i] = ReadSingle(); + + return data; + } + + public unsafe double ReadDouble() + { + ulong value = ReadUInt64(); + return *((double*)&value); + } + + public Vector2 ReadVector2() + { + return new Vector2(ReadSingle(), ReadSingle()); + } + + public Vector2[] ReadVector2VarArray() + { + return ReadVector2Array(ReadInt32()); + } + + public Vector2[] ReadVector2Array(int length) + { + var data = new Vector2[length]; + + for (int i = 0; i < data.Length; i++) + data[i] = ReadVector2(); + + return data; + } + + public Vector3 ReadVector3() + { + return new Vector3(ReadSingle(), ReadSingle(), ReadSingle()); + } + + public Vector3[] ReadVector3VarArray() + { + return ReadVector3Array(ReadInt32()); + } + + public Vector3[] ReadVector3Array(int length) + { + var data = new Vector3[length]; + + for (int i = 0; i < data.Length; i++) + data[i] = ReadVector3(); + + return data; + } + + public Plane ReadPlane() + { + return new Plane(ReadVector3(), ReadSingle()); + } + + public Plane[] ReadPlaneVarArray() + { + return ReadPlaneArray(ReadInt32()); + } + + public Plane[] ReadPlaneArray(int length) + { + var data = new Plane[length]; + + for (int i = 0; i < data.Length; i++) + data[i] = ReadPlane(); + + return data; + } + + public Quaternion ReadQuaternion() + { + return new Quaternion(ReadSingle(), ReadSingle(), ReadSingle(), -ReadSingle()); + } + + public Quaternion ReadCompressedQuaternion() + { + return Quaternion.CreateFromAxisAngle(Vector3.UnitX, ReadInt16() * rotationAngleScale) + * Quaternion.CreateFromAxisAngle(Vector3.UnitY, ReadInt16() * rotationAngleScale) + * Quaternion.CreateFromAxisAngle(Vector3.UnitZ, ReadInt16() * rotationAngleScale); + } + + public BoundingBox ReadBoundingBox() + { + return new BoundingBox(ReadVector3(), ReadVector3()); + } + + public Matrix ReadMatrix4x3() + { + Matrix m; + m.M11 = ReadSingle(); + m.M12 = ReadSingle(); + m.M13 = ReadSingle(); + m.M14 = 0.0f; + m.M21 = ReadSingle(); + m.M22 = ReadSingle(); + m.M23 = ReadSingle(); + m.M24 = 0.0f; + m.M31 = ReadSingle(); + m.M32 = ReadSingle(); + m.M33 = ReadSingle(); + m.M34 = 0.0f; + m.M41 = ReadSingle(); + m.M42 = ReadSingle(); + m.M43 = ReadSingle(); + m.M44 = 1.0f; + return m; + } + + public Color ReadColor() + { + uint color = ReadUInt32(); + + var r = (byte)((color >> 16) & 0xff); + var g = (byte)((color >> 08) & 0xff); + var b = (byte)((color >> 00) & 0xff); + var a = (byte)((color >> 24) & 0xff); + + return new Color(r, g, b, a); + } + + public Color[] ReadColorArray(int length) + { + var data = new Color[length]; + + for (int i = 0; i < data.Length; i++) + data[i] = ReadColor(); + + return data; + } + + public string ReadString(int maxLength) + { + var bytes = ReadBytes(maxLength); + + for (int i = 0; i < bytes.Length; i++) + { + if (bytes[i] == 0) + return encoding.GetString(bytes, 0, i); + } + + return encoding.GetString(bytes); + } + + public string ReadCString() + { + var buffer = new List(64); + byte b; + + while ((b = ReadByte()) != 0) + buffer.Add(b); + + return encoding.GetString(buffer.ToArray()); + } + + public InstanceDescriptor ReadInstance() + { + return instanceFile.ResolveLink(ReadInt32()); + } + + public InstanceDescriptor[] ReadInstanceArray(int length) + { + var data = new InstanceDescriptor[length]; + + for (int i = 0; i < data.Length; i++) + data[i] = ReadInstance(); + + return data; + } + + public InstanceDescriptor ReadLink() + { + return instanceFile.GetDescriptor(ReadInt32()); + } + + public InstanceDescriptor[] ReadLinkArray(int length) + { + var data = new InstanceDescriptor[length]; + + for (int i = 0; i < data.Length; i++) + data[i] = ReadLink(); + + return data; + } + + private void FillBuffer(int count) + { + int offset = 0; + + while (count > 0) + { + int read = stream.Read(buffer, offset, count); + + if (read == 0) + throw new EndOfStreamException(); + + offset += read; + count -= read; + } + } + } +} Index: /OniSplit/BinaryWriter.cs =================================================================== --- /OniSplit/BinaryWriter.cs (revision 1114) +++ /OniSplit/BinaryWriter.cs (revision 1114) @@ -0,0 +1,297 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Text; +using Oni.Imaging; + +namespace Oni +{ + internal class BinaryWriter : System.IO.BinaryWriter + { + private static readonly byte[] padding = new byte[32]; + private static readonly Encoding encoding = Encoding.UTF8; + private readonly Stack positionStack = new Stack(); + + public BinaryWriter(Stream stream) + : base(stream, encoding) + { + } + + public void WriteInstanceId(int index) + { + Write(InstanceFileWriter.MakeInstanceId(index)); + } + + public void Write(IEnumerable descriptors) + { + foreach (var descriptor in descriptors) + Write(descriptor); + } + + public void Write(ImporterDescriptor descriptor) + { + if (descriptor == null) + Write(0); + else + Write(InstanceFileWriter.MakeInstanceId(descriptor.Index)); + } + + public void Write(Color c) + { + Write(c.ToBgra32()); + } + + public void Write(Vector2 v) + { + Write(v.X); + Write(v.Y); + } + + public void Write(Vector3 v) + { + Write(v.X); + Write(v.Y); + Write(v.Z); + } + + public void Write(Vector4 v) + { + Write(v.X); + Write(v.Y); + Write(v.Z); + Write(v.W); + } + + public void Write(Quaternion q) + { + Write(q.X); + Write(q.Y); + Write(q.Z); + Write(-q.W); + } + + public void Write(Plane p) + { + Write(p.Normal); + Write(p.D); + } + + public void Write(BoundingBox bbox) + { + Write(bbox.Min); + Write(bbox.Max); + } + + public void Write(BoundingSphere bsphere) + { + Write(bsphere.Center); + Write(bsphere.Radius); + } + + public void WriteMatrix4x3(Matrix m) + { + Write(m.M11); + Write(m.M12); + Write(m.M13); + Write(m.M21); + Write(m.M22); + Write(m.M23); + Write(m.M31); + Write(m.M32); + Write(m.M33); + Write(m.M41); + Write(m.M42); + Write(m.M43); + } + + public void Write(short[] a) + { + foreach (short v in a) + Write(v); + } + + public void Write(ushort[] a) + { + foreach (ushort v in a) + Write(v); + } + + public void Write(int[] a) + { + foreach (int v in a) + Write(v); + } + + public void Write(int[] v, int startIndex, int length) + { + for (int i = startIndex; i < startIndex + length; i++) + Write(v[i]); + } + + public void Write(IEnumerable a) + { + foreach (float v in a) + Write(v); + } + + public void Write(IEnumerable a) + { + foreach (int i in a) + Write(i); + } + + public void Write(Color[] a) + { + foreach (Color v in a) + Write(v); + } + + public void Write(IEnumerable a) + { + foreach (Vector2 v in a) + Write(v); + } + + public void Write(IEnumerable a) + { + foreach (Vector3 v in a) + Write(v); + } + + public void Write(IEnumerable a) + { + foreach (Plane v in a) + Write(v); + } + + public void Write(string s, int maxLength) + { + if (s == null) + { + Skip(maxLength); + return; + } + + if (encoding.GetByteCount(s) > maxLength) + throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "The string '{0}' is too long (max length is {1})", s, maxLength)); + + byte[] data = new byte[maxLength]; + encoding.GetBytes(s, 0, s.Length, data, 0); + Write(data); + } + + public void WriteByte(int value) + { + if (value < byte.MinValue || byte.MaxValue < value) + throw new ArgumentOutOfRangeException("Value too large for Byte", "value"); + + Write((byte)value); + } + + public void WriteInt16(int value) + { + if (value < short.MinValue || short.MaxValue < value) + throw new ArgumentOutOfRangeException("Value too large for Int16", "value"); + + Write((short)value); + } + + public void WriteUInt16(int value) + { + if (value < 0 || value > UInt16.MaxValue) + throw new ArgumentOutOfRangeException("Value too large for UInt16", "value"); + + Write((ushort)value); + } + + public void Write(byte value, int count) + { + if (value == 0 && Position == OutStream.Length) + { + Seek(count, SeekOrigin.Current); + } + else + { + for (int i = 0; i < count; i++) + Write(value); + } + } + + public void Skip(int length) + { + Position += length; + } + + public override Stream BaseStream + { + get + { + // + // Note: return base OutStream directly instead of BaseStream to avoid + // flushing the stream. + // + + return base.OutStream; + } + } + + public void PushPosition(int newPosition) + { + positionStack.Push(Position); + Position = newPosition; + } + + public void PopPosition() + { + Position = positionStack.Pop(); + } + + public int Position + { + get + { + return (int)BaseStream.Position; + } + set + { + int currentPosition = (int)OutStream.Position; + int delta = value - currentPosition; + + if (delta == 0) + return; + + // + // Prevent changing the output stream position for small changes of position. + // This avoids flushing the write cache of the stream which results in poor perf. + // + + if (0 < delta && delta <= 32 && Position == OutStream.Length) + OutStream.Write(padding, 0, delta); + else + OutStream.Position = value; + } + } + + public void WriteAt(int position, int value) + { + PushPosition(position); + Write(value); + PopPosition(); + } + + public void WriteAt(int position, short value) + { + PushPosition(position); + Write(value); + PopPosition(); + } + + public int Align32() + { + int position = Utils.Align32(Position); + Position = position; + return position; + } + } +} Index: /OniSplit/Collections/Set.cs =================================================================== --- /OniSplit/Collections/Set.cs (revision 1114) +++ /OniSplit/Collections/Set.cs (revision 1114) @@ -0,0 +1,47 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Collections +{ + internal class Set : IEnumerable + { + private readonly Dictionary set; + + public Set() + { + set = new Dictionary(); + } + + public Set(IEqualityComparer comparer) + { + set = new Dictionary(comparer); + } + + public bool Add(T t) + { + if (set.ContainsKey(t)) + return false; + + set.Add(t, 0); + return true; + } + + public bool Contains(T t) => set.ContainsKey(t); + + public int Count => set.Count; + + public void UnionWith(IEnumerable with) + { + foreach (T t in with) + set[t] = 0; + } + + public IEnumerator GetEnumerator() + { + foreach (var pair in set) + yield return pair.Key; + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator(); + } +} Index: /OniSplit/Dae/Axis.cs =================================================================== --- /OniSplit/Dae/Axis.cs (revision 1114) +++ /OniSplit/Dae/Axis.cs (revision 1114) @@ -0,0 +1,9 @@ +namespace Oni.Dae +{ + internal enum Axis + { + X, + Y, + Z + } +} Index: /OniSplit/Dae/Camera.cs =================================================================== --- /OniSplit/Dae/Camera.cs (revision 1114) +++ /OniSplit/Dae/Camera.cs (revision 1114) @@ -0,0 +1,14 @@ +namespace Oni.Dae +{ + internal class Camera : Entity + { + public CameraType Type { get; set; } + public float XMag { get; set; } + public float YMag { get; set; } + public float XFov { get; set; } + public float YFov { get; set; } + public float AspectRatio { get; set; } + public float ZNear { get; set; } + public float ZFar { get; set; } + } +} Index: /OniSplit/Dae/CameraInstance.cs =================================================================== --- /OniSplit/Dae/CameraInstance.cs (revision 1114) +++ /OniSplit/Dae/CameraInstance.cs (revision 1114) @@ -0,0 +1,14 @@ +namespace Oni.Dae +{ + internal class CameraInstance : Instance + { + public CameraInstance() + { + } + + public CameraInstance(Camera camera) + : base(camera) + { + } + } +} Index: /OniSplit/Dae/CameraType.cs =================================================================== --- /OniSplit/Dae/CameraType.cs (revision 1114) +++ /OniSplit/Dae/CameraType.cs (revision 1114) @@ -0,0 +1,8 @@ +namespace Oni.Dae +{ + internal enum CameraType + { + Perspective, + Orthographic + } +} Index: /OniSplit/Dae/Converters/AxisConverter.cs =================================================================== --- /OniSplit/Dae/Converters/AxisConverter.cs (revision 1114) +++ /OniSplit/Dae/Converters/AxisConverter.cs (revision 1114) @@ -0,0 +1,215 @@ +using System; +using System.Collections.Generic; +using Oni.Collections; + +namespace Oni.Dae +{ + internal class AxisConverter + { + private Scene scene; + private Axis fromUpAxis; + private Axis toUpAxis; + private Set convertedValues; + + public static void Convert(Scene scene, Axis fromUpAxis, Axis toUpAxis) + { + var converter = new AxisConverter { + scene = scene, + fromUpAxis = fromUpAxis, + toUpAxis = toUpAxis, + convertedValues = new Set() + }; + + converter.Convert(); + } + + private void Convert() + { + Convert(scene); + } + + private void Convert(Node node) + { + foreach (var transform in node.Transforms) + Convert(transform); + + foreach (var instance in node.Instances) + Convert(instance); + + foreach (var child in node.Nodes) + Convert(child); + } + + private void Convert(Instance instance) + { + var geometryInstance = instance as GeometryInstance; + + if (geometryInstance != null) + { + Convert(geometryInstance.Target); + return; + } + } + + private void Convert(Geometry geometry) + { + foreach (var primitives in geometry.Primitives) + { + // + // HACK: this assumes that position and normal sources are never reused with other semantic + // + + foreach (var input in primitives.Inputs) + { + if (input.Semantic == Semantic.Position || input.Semantic == Semantic.Normal) + ConvertPosition(input.Source.FloatData, input.Source.Stride); + } + } + } + + private void Convert(Transform transform) + { + var scale = transform as TransformScale; + + if (scale != null) + { + ConvertScale(scale.Values, 3); + + if (transform.HasAnimations) + ConvertScaleAnimation(transform); + + return; + } + + var rotate = transform as TransformRotate; + + if (rotate != null) + { + //ConvertPosition(rotate.Values, 3); + + if (transform.HasAnimations) + ConvertRotationAnimation(transform); + + return; + } + + var translate = transform as TransformTranslate; + + if (translate != null) + { + ConvertPosition(translate.Values, 3); + + if (transform.HasAnimations) + ConvertPositionAnimation(transform); + + return; + } + + var matrix = transform as TransformMatrix; + + if (matrix != null) + { + ConvertMatrix(matrix); + + // + // TODO: matrix animation??? + // + + return; + } + } + + private void ConvertMatrix(TransformMatrix transform) + { + if (fromUpAxis == Axis.Z && toUpAxis == Axis.Y) + { + Matrix zm = transform.Matrix; + Matrix ym = zm; + //Matrix ym = Matrix.CreateRotationX( + // MathHelper.PiOver2) * + //zm * + //Matrix.CreateRotationX( + // -MathHelper.PiOver2); + ym.M12 = zm.M13; + ym.M13 = -zm.M12; + ym.M21 = zm.M31; + ym.M22 = zm.M33; + ym.M23 = -zm.M32; + ym.M31 = -zm.M21; + ym.M32 = -zm.M23; + ym.M33 = zm.M22; + ym.M42 = zm.M43; + ym.M43 = -zm.M42; + transform.Matrix = ym; + } + //else if (fromUpAxis == Axis.Y && toUpAxis == Axis.Z) + //{ + // rotate.XAxis = new Vector3(1.0f, 0.0f, 0.0f); + // rotate.YAxis = new Vector3(0.0f, 0.0f, -1.0f); + // rotate.ZAxis = new Vector3(0.0f, 1.0f, 0.0f); + //} + //else if (fromUpAxis == Axis.X && toUpAxis == Axis.Y) + //{ + // rotate.XAxis = new Vector3(0.0f, 0.0f, -1.0f); + // rotate.YAxis = new Vector3(1.0f, 0.0f, 1.0f); + // rotate.ZAxis = new Vector3(0.0f, 1.0f, 0.0f); + //} + } + + private void ConvertPosition(float[] values, int stride) + { + if (!convertedValues.Add(values)) + return; + + for (int i = 0; i + stride - 1 < values.Length; i += stride) + Convert(values, i, f => -f); + } + + private void ConvertPositionAnimation(Transform transform) + { + Convert(transform.Animations, 0, s => s != null ? s.Scale(-1.0f) : null); + } + + private void ConvertRotationAnimation(Transform transform) + { + ConvertPositionAnimation(transform); + } + + private void ConvertScale(float[] values, int stride) + { + for (int i = 0; i + stride - 1 < values.Length; i += stride) + Convert(values, i, null); + } + + private void ConvertScaleAnimation(Transform transform) + { + Convert(transform.Animations, 0, null); + } + + private void Convert(IList list, int baseIndex, Func negate) + { + T t0 = list[baseIndex + 0]; + T t1 = list[baseIndex + 1]; + T t2 = list[baseIndex + 2]; + + if (fromUpAxis == Axis.Z && toUpAxis == Axis.Y) + { + list[baseIndex + 0] = t0; + list[baseIndex + 1] = t2; + list[baseIndex + 2] = negate != null ? negate(t1) : t1; + } + else if (fromUpAxis == Axis.Y && toUpAxis == Axis.Z) + { + list[baseIndex + 0] = t0; + list[baseIndex + 1] = negate != null ? negate(t2) : t2; + list[baseIndex + 2] = t1; + } + else if (fromUpAxis == Axis.X && toUpAxis == Axis.Y) + { + list[baseIndex + 0] = negate != null ? negate(t2) : t2; + list[baseIndex + 1] = t0; + list[baseIndex + 2] = t1; + } + } + } +} Index: /OniSplit/Dae/Converters/FaceConverter.cs =================================================================== --- /OniSplit/Dae/Converters/FaceConverter.cs (revision 1114) +++ /OniSplit/Dae/Converters/FaceConverter.cs (revision 1114) @@ -0,0 +1,169 @@ +using System; +using System.Collections.Generic; +using Oni.Collections; + +namespace Oni.Dae +{ + internal class FaceConverter + { + private Node root; + private int maxEdges = 3; + + public static void Triangulate(Node root) + { + var converter = new FaceConverter { + root = root + }; + + converter.Convert(); + } + + private void Convert() + { + ConvertNode(root); + } + + private void ConvertNode(Node node) + { + foreach (var instance in node.Instances) + ConvertInstance(instance); + + foreach (var child in node.Nodes) + ConvertNode(child); + } + + private void ConvertInstance(Instance instance) + { + var geometryInstance = instance as GeometryInstance; + + if (geometryInstance != null) + { + ConvertGeometry(geometryInstance.Target); + return; + } + } + + private void ConvertGeometry(Geometry geometry) + { + foreach (var primitives in geometry.Primitives) + { + if (primitives.PrimitiveType != MeshPrimitiveType.Polygons) + continue; + + if (primitives.VertexCounts.All(c => c == 3)) + continue; + + ConvertPolygons(geometry, primitives); + } + } + + private void ConvertPolygons(Geometry geometry, MeshPrimitives primitives) + { + var positionInput = primitives.Inputs.FirstOrDefault(i => i.Semantic == Semantic.Position); + + if (positionInput == null) + { + Console.Error.WriteLine("{0}: cannot find position input", geometry.Name); + return; + } + + var newFaces = new List(primitives.VertexCounts.Count * 2); + var newVertexCounts = new List(primitives.VertexCounts.Count * 2); + int voffset = 0; + + foreach (int vcount in primitives.VertexCounts) + { + if (vcount < 3) + { + Console.Error.WriteLine("{0}: skipping bad face (line)", geometry.Name); + } + else if (vcount <= maxEdges) + { + for (int i = 0; i < vcount; i++) + newFaces.Add(voffset + i); + + newVertexCounts.Add(vcount); + } + else + { + ConvertPolygon(geometry, positionInput, voffset, vcount, newFaces, newVertexCounts); + } + + voffset += vcount; + } + + primitives.VertexCounts.Clear(); + primitives.VertexCounts.AddRange(newVertexCounts); + + var oldIndices = new int[primitives.Inputs.Count][]; + + for (int i = 0; i < primitives.Inputs.Count; i++) + { + var input = primitives.Inputs[i]; + oldIndices[i] = input.Indices.ToArray(); + input.Indices.Clear(); + } + + for (int i = 0; i < primitives.Inputs.Count; i++) + { + var ni = primitives.Inputs[i].Indices; + var oi = oldIndices[i]; + + foreach (int v in newFaces) + ni.Add(oi[v]); + } + } + + private void ConvertPolygon(Geometry geometry, IndexedInput input, int offset, int vcount, List newFaces, List newVertexCounts) + { + var points = new Vector3[vcount]; + + for (int i = 0; i < vcount; i++) + points[i] = Dae.Source.ReadVector3(input.Source, input.Indices[offset + i]); + + int concave = -1; + + for (int i = 0; i < vcount; i++) + { + Vector3 p0 = points[i]; + Vector3 p1 = points[(i + 1) % vcount]; + + if (Vector3.Dot(p0, p1) < 0.0f) + { + concave = i; + break; + } + } + + if (concave == -1) + { + for (int i = 0; i < vcount - 2; i++) + { + newFaces.Add(offset + 0); + newFaces.Add(offset + 1 + i); + newFaces.Add(offset + 2 + i); + newVertexCounts.Add(3); + } + + return; + } + + if (vcount == 4) + { + newFaces.Add(offset + concave); + newFaces.Add(offset + (concave + 1) % vcount); + newFaces.Add(offset + (concave + 2) % vcount); + newVertexCounts.Add(3); + + newFaces.Add(offset + (concave + vcount - 1) % vcount); + newFaces.Add(offset + (concave + vcount - 2) % vcount); + newFaces.Add(offset + concave); + newVertexCounts.Add(3); + + return; + } + + Console.Error.WriteLine("{0}: skipping bad face (concave {1}-gon)", geometry.Name, vcount); + } + } +} Index: /OniSplit/Dae/Converters/UnitConverter.cs =================================================================== --- /OniSplit/Dae/Converters/UnitConverter.cs (revision 1114) +++ /OniSplit/Dae/Converters/UnitConverter.cs (revision 1114) @@ -0,0 +1,113 @@ +using System; +using System.Collections.Generic; +using Oni.Collections; + +namespace Oni.Dae +{ + internal class UnitConverter + { + private Scene scene; + private float scale; + private Set scaledValues; + + public static void Convert(Scene scene, float scale) + { + var converter = new UnitConverter { + scene = scene, + scale = scale, + scaledValues = new Set() + }; + + converter.Convert(); + } + + private void Convert() + { + Convert(scene); + } + + private void Convert(Node node) + { + foreach (var transform in node.Transforms) + Convert(transform); + + foreach (var instance in node.Instances) + Convert(instance); + + foreach (var child in node.Nodes) + Convert(child); + } + + private void Convert(Instance instance) + { + var geometryInstance = instance as GeometryInstance; + + if (geometryInstance != null) + { + Convert(geometryInstance.Target); + return; + } + } + + private void Convert(Geometry geometry) + { + foreach (var primitives in geometry.Primitives) + { + // + // TODO: this assumes that position sources are not reused. + // + + foreach (var input in primitives.Inputs) + { + if (input.Semantic == Semantic.Position) + Scale(input.Source.FloatData, input.Source.Stride); + } + } + } + + private void Convert(Transform transform) + { + var translate = transform as TransformTranslate; + + if (translate != null) + { + Scale(translate.Values, 3); + + if (translate.HasAnimations) + { + for (int i = 0; i < translate.Animations.Length; i++) + { + Sampler s = translate.Animations[i]; + translate.Animations[i] = s == null ? null : s.Scale(scale); + } + } + + return; + } + + var matrix = transform as TransformMatrix; + + if (matrix != null) + { + matrix.Values[3] *= scale; + matrix.Values[7] *= scale; + matrix.Values[11] *= scale; + + return; + } + } + + private void Scale(float[] values, int stride) + { + if (!scaledValues.Add(values)) + return; + + for (int i = 0; i + stride - 1 < values.Length; i += stride) + { + values[i + 0] *= scale; + values[i + 1] *= scale; + values[i + 2] *= scale; + } + } + } +} Index: /OniSplit/Dae/Effect.cs =================================================================== --- /OniSplit/Dae/Effect.cs (revision 1114) +++ /OniSplit/Dae/Effect.cs (revision 1114) @@ -0,0 +1,100 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal class Effect : Entity + { + private readonly List parameters; + private readonly EffectParameter emission; + private readonly EffectParameter ambient; + private readonly EffectParameter diffuse; + private readonly EffectParameter specular; + private readonly EffectParameter shininess; + private readonly EffectParameter reflective; + private readonly EffectParameter reflectivity; + private readonly EffectParameter transparent; + private readonly EffectParameter transparency; + private readonly EffectParameter indexOfRefraction; + + public Effect() + { + parameters = new List(); + + var alphaOne = new Vector4(0.0f, 0.0f, 0.0f, 1.0f); + + emission = new EffectParameter("emission", alphaOne, this); + ambient = new EffectParameter("ambient", alphaOne, this); + diffuse = new EffectParameter("diffuse", alphaOne, this); + specular = new EffectParameter("specular", alphaOne, this); + shininess = new EffectParameter("shininess", 20.0f, this); + reflective = new EffectParameter("reflective", 1.0f, this); + reflectivity = new EffectParameter("reflectivity", Vector4.One, this); + transparent = new EffectParameter("transparent", alphaOne, this); + transparency = new EffectParameter("transparency", 1.0f, this); + indexOfRefraction = new EffectParameter("index_of_refraction", 1.0f, this); + } + + public EffectType Type { get; set; } + + public List Parameters => parameters; + + public IEnumerable Textures + { + get + { + foreach (var param in new[] { diffuse, ambient, specular, reflective, transparent, emission }) + { + var texture = param.Value as EffectTexture; + + if (texture != null) + yield return texture; + } + } + } + + public EffectParameter Emission => emission; + + public EffectParameter Ambient => ambient; + + public object AmbientValue + { + get { return ambient.Value; } + set { ambient.Value = value; } + } + + public EffectParameter Diffuse => diffuse; + + public object DiffuseValue + { + get { return diffuse.Value; } + set { diffuse.Value = value; } + } + + public EffectParameter Specular => specular; + + public object SpecularValue + { + get { return specular.Value; } + set { specular.Value = value; } + } + + public EffectParameter Shininess => shininess; + + public EffectParameter Reflective => reflective; + + public EffectParameter Reflectivity => reflectivity; + + public EffectParameter Transparent => transparent; + + public object TransparentValue + { + get { return transparent.Value; } + set { transparent.Value = value; } + } + + public EffectParameter Transparency => transparency; + + public EffectParameter IndexOfRefraction => indexOfRefraction; + } +} Index: /OniSplit/Dae/EffectParameter.cs =================================================================== --- /OniSplit/Dae/EffectParameter.cs (revision 1114) +++ /OniSplit/Dae/EffectParameter.cs (revision 1114) @@ -0,0 +1,83 @@ +using System; + +namespace Oni.Dae +{ + internal class EffectParameter + { + private object value; + private string reference; + + public EffectParameter() + { + } + + public EffectParameter(string sid, object value) + { + Sid = sid; + this.value = value; + SetValueOwner(this); + } + + public EffectParameter(string sid, object value, Effect parent) + { + Sid = sid; + this.value = value; + } + + public string Sid { get; set; } + public string Semantic { get; set; } + + public object Value + { + get + { + return value; + } + set + { + SetValueOwner(null); + + this.value = value; + + if (value != null) + reference = null; + + SetValueOwner(this); + } + } + + private void SetValueOwner(EffectParameter owner) + { + EffectSampler sampler = value as EffectSampler; + + if (sampler != null) + { + sampler.Owner = owner; + return; + } + + EffectSurface surface = value as EffectSurface; + + if (surface != null) + { + surface.DeclaringParameter = owner; + return; + } + } + + public string Reference + { + get + { + return reference; + } + set + { + reference = value; + + if (reference != null) + this.value = null; + } + } + } +} Index: /OniSplit/Dae/EffectSampler.cs =================================================================== --- /OniSplit/Dae/EffectSampler.cs (revision 1114) +++ /OniSplit/Dae/EffectSampler.cs (revision 1114) @@ -0,0 +1,22 @@ +namespace Oni.Dae +{ + internal class EffectSampler + { + public EffectSampler() + { + } + + public EffectSampler(EffectSurface surface) + { + Surface = surface; + } + + public EffectParameter Owner { get; set; } + public EffectSurface Surface { get; set; } + public EffectSamplerWrap WrapS { get; set; } = EffectSamplerWrap.Wrap; + public EffectSamplerWrap WrapT { get; set; } = EffectSamplerWrap.Wrap; + public EffectSamplerFilter MinFilter { get; set; } + public EffectSamplerFilter MagFilter { get; set; } + public EffectSamplerFilter MipFilter { get; set; } + } +} Index: /OniSplit/Dae/EffectSamplerFilter.cs =================================================================== --- /OniSplit/Dae/EffectSamplerFilter.cs (revision 1114) +++ /OniSplit/Dae/EffectSamplerFilter.cs (revision 1114) @@ -0,0 +1,13 @@ +namespace Oni.Dae +{ + internal enum EffectSamplerFilter + { + None, + Nearest, + Linear, + NearestMipmapNearest, + LinearMipmapNearest, + NearestMipmapLinear, + LinearMipmapLinear + } +} Index: /OniSplit/Dae/EffectSamplerWrap.cs =================================================================== --- /OniSplit/Dae/EffectSamplerWrap.cs (revision 1114) +++ /OniSplit/Dae/EffectSamplerWrap.cs (revision 1114) @@ -0,0 +1,11 @@ +namespace Oni.Dae +{ + internal enum EffectSamplerWrap + { + None, + Wrap, + Mirror, + Clamp, + Border + } +} Index: /OniSplit/Dae/EffectSurface.cs =================================================================== --- /OniSplit/Dae/EffectSurface.cs (revision 1114) +++ /OniSplit/Dae/EffectSurface.cs (revision 1114) @@ -0,0 +1,17 @@ +namespace Oni.Dae +{ + internal class EffectSurface + { + public EffectSurface() + { + } + + public EffectSurface(Image initFrom) + { + InitFrom = initFrom; + } + + public EffectParameter DeclaringParameter { get; set; } + public Image InitFrom { get; set; } + } +} Index: /OniSplit/Dae/EffectTexture.cs =================================================================== --- /OniSplit/Dae/EffectTexture.cs (revision 1114) +++ /OniSplit/Dae/EffectTexture.cs (revision 1114) @@ -0,0 +1,19 @@ +namespace Oni.Dae +{ + internal class EffectTexture + { + public EffectTexture() + { + } + + public EffectTexture(EffectSampler sampler, string texCoordSemantic) + { + TexCoordSemantic = texCoordSemantic; + Sampler = sampler; + } + + public string TexCoordSemantic { get; set; } + public EffectTextureChannel Channel { get; set; } + public EffectSampler Sampler { get; set; } + } +} Index: /OniSplit/Dae/EffectTextureChannel.cs =================================================================== --- /OniSplit/Dae/EffectTextureChannel.cs (revision 1114) +++ /OniSplit/Dae/EffectTextureChannel.cs (revision 1114) @@ -0,0 +1,13 @@ +namespace Oni.Dae +{ + internal enum EffectTextureChannel + { + None, + Emission, + Ambient, + Diffuse, + Specular, + Reflective, + Transparent + } +} Index: /OniSplit/Dae/EffectType.cs =================================================================== --- /OniSplit/Dae/EffectType.cs (revision 1114) +++ /OniSplit/Dae/EffectType.cs (revision 1114) @@ -0,0 +1,10 @@ +namespace Oni.Dae +{ + internal enum EffectType + { + Constant, + Lambert, + Phong, + Blinn + } +} Index: /OniSplit/Dae/Entity.cs =================================================================== --- /OniSplit/Dae/Entity.cs (revision 1114) +++ /OniSplit/Dae/Entity.cs (revision 1114) @@ -0,0 +1,9 @@ +namespace Oni.Dae +{ + internal abstract class Entity + { + public string Id { get; set; } + public string Name { get; set; } + public string FileName { get; set; } + } +} Index: /OniSplit/Dae/Geometry.cs =================================================================== --- /OniSplit/Dae/Geometry.cs (revision 1114) +++ /OniSplit/Dae/Geometry.cs (revision 1114) @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal class Geometry : Entity + { + public readonly List primitives = new List(1); + public readonly List vertices = new List(1); + + public List Vertices => vertices; + public List Primitives => primitives; + } +} Index: /OniSplit/Dae/GeometryInstance.cs =================================================================== --- /OniSplit/Dae/GeometryInstance.cs (revision 1114) +++ /OniSplit/Dae/GeometryInstance.cs (revision 1114) @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal class GeometryInstance : Instance + { + private readonly List materials = new List(1); + + public GeometryInstance() + { + } + + public GeometryInstance(Geometry geometry) + : base(geometry) + { + } + + public List Materials => materials; + } +} Index: /OniSplit/Dae/IO/DaeReader.cs =================================================================== --- /OniSplit/Dae/IO/DaeReader.cs (revision 1114) +++ /OniSplit/Dae/IO/DaeReader.cs (revision 1114) @@ -0,0 +1,1894 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Globalization; +using System.Xml; +using Oni.Xml; + +namespace Oni.Dae.IO +{ + internal class DaeReader + { + public static string[] CommandLineArgs; + + #region Private data + private static readonly string[] emptyStrings = new string[0]; + private static readonly char[] whiteSpaceChars = new char[] { ' ', '\t' }; + private static readonly Func intConverter = XmlConvert.ToInt32; + private static readonly Func floatConverter = XmlConvert.ToSingle; + private TextWriter error; + private TextWriter info; + private Scene mainScene; + private Dictionary entities; + private XmlReader xml; + private Axis upAxis = Axis.Y; + private float unit = 1.0f; + private List delayedBindActions; + private Uri baseUrl; + private string fileName; + private List scenes = new List(); + private List lights = new List(); + private List animations = new List(); + private List geometries = new List(); + private List effects = new List(); + private List materials = new List(); + private List images = new List(); + private List cameras = new List(); + #endregion + + #region private class Animation + + private class Animation : Entity + { + private List animations; + private readonly List samplers = new List(); + + public List Animations + { + get + { + if (animations == null) + animations = new List(); + + return animations; + } + } + + public List Samplers => samplers; + } + + #endregion + + public static Scene ReadFile(string filePath) + { + var reader = new DaeReader { + baseUrl = new Uri("file://" + Path.GetDirectoryName(filePath).Replace('\\', '/').TrimEnd('/') + "/"), + fileName = Path.GetFileName(filePath), + delayedBindActions = new List(), + error = Console.Error, + info = Console.Out + }; + + var settings = new XmlReaderSettings { + IgnoreWhitespace = true, + IgnoreProcessingInstructions = true, + IgnoreComments = true + }; + + using (reader.xml = XmlReader.Create(filePath, settings)) + reader.ReadRoot(); + + return reader.mainScene; + } + + private void ReadRoot() + { + while (xml.NodeType != XmlNodeType.Element) + xml.Read(); + + if (xml.LocalName != "COLLADA") + throw new InvalidDataException(string.Format("Unknown root element {0} found", xml.LocalName)); + + string version = xml.GetAttribute("version"); + + if (version != "1.4.0" && version != "1.4.1") + throw new NotSupportedException(string.Format("Unsupported Collada file version {0}", version)); + + if (!xml.IsEmptyElement) + { + xml.ReadStartElement(); + + ReadAsset(); + ReadContent(); + ReadExtra(); + } + + foreach (var action in delayedBindActions) + action(); + + if (mainScene == null && scenes.Count > 0) + mainScene = scenes[0]; + + BindNodes(mainScene); + + if (upAxis != Axis.Y) + AxisConverter.Convert(mainScene, upAxis, Axis.Y); + + float scale = 1.0f; + + if (CommandLineArgs != null) + { + string scaleArg = Array.Find(CommandLineArgs, x => x.StartsWith("-dae-scale:", StringComparison.Ordinal)); + + if (scaleArg != null) + scale = float.Parse(scaleArg.Substring(11), CultureInfo.InvariantCulture); + } + + if (unit != 0.1f || scale != 1.0f) + UnitConverter.Convert(mainScene, 10.0f * unit * scale); + } + + private void ReadContent() + { + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "library_cameras": + ReadLibrary(cameras, "camera", ReadCamera); + break; + + case "library_images": + ReadLibrary(images, "image", ReadImage); + break; + + case "library_effects": + ReadLibrary(effects, "effect", ReadEffect); + break; + + case "library_materials": + ReadLibrary(materials, "material", ReadMaterial); + break; + + case "library_geometries": + ReadLibrary(geometries, "geometry", ReadGeometry); + break; + + case "library_nodes": + ReadLibrary(scenes, "node", ReadNode); + break; + + case "library_visual_scenes": + ReadLibrary(scenes, "visual_scene", ReadScene); + break; + + case "library_animations": + ReadLibrary(animations, "animation", ReadAnimation); + break; + + case "library_lights": + ReadLibrary(lights, "light", ReadLight); + break; + + case "scene": + ReadScene(); + break; + + default: + xml.Skip(); + break; + } + } + } + + // + // Libraries + // + + private void ReadLibrary(ICollection library, string elementName, Action entityReader) + where T : Entity, new() + { + if (xml.SkipEmpty()) + return; + + xml.ReadStartElement(); + ReadAsset(); + + while (xml.IsStartElement(elementName)) + ReadEntity(library, entityReader); + + ReadExtra(); + xml.ReadEndElement(); + } + + private void ReadEntity(ICollection entityCollection, Action entityReader) + where T : Entity, new() + { + T entity = ReadEntity(entityReader); + entityCollection.Add(entity); + } + + private T ReadEntity(Action entityReader) + where T : Entity, new() + { + string id = xml.GetAttribute("id"); + + var entity = new T { + Name = xml.GetAttribute("name"), + FileName = fileName + }; + + AddEntity(id, entity); + + if (string.IsNullOrEmpty(entity.Name)) + entity.Name = id; + + if (xml.IsEmptyElement) + { + xml.ReadStartElement(); + return entity; + } + + xml.ReadStartElement(); + ReadAsset(); + + entityReader(entity); + + ReadExtra(); + xml.ReadEndElement(); + + return entity; + } + + // + // Cameras + // + + private void ReadCamera(Camera camera) + { + ReadAsset(); + + xml.ReadStartElement("optics"); + xml.ReadStartElement("technique_common"); + + if (xml.IsStartElement("perspective")) + ReadCameraParameters(camera, CameraType.Perspective); + else if (xml.IsStartElement("orthographic")) + ReadCameraParameters(camera, CameraType.Orthographic); + else if (xml.IsStartElement()) + xml.Skip(); + + xml.ReadEndElement(); + + while (xml.IsStartElement()) + xml.Skip(); + + xml.ReadEndElement(); + + if (xml.IsStartElement("imager")) + xml.Skip(); + + ReadExtra(); + } + + private void ReadCameraParameters(Camera camera, CameraType type) + { + xml.ReadStartElement(); + + camera.Type = type; + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "xfov": + camera.XFov = xml.ReadElementContentAsFloat(); + break; + case "yfov": + camera.YFov = xml.ReadElementContentAsFloat(); + break; + case "xmag": + camera.XMag = xml.ReadElementContentAsFloat(); + break; + case "ymag": + camera.YMag = xml.ReadElementContentAsFloat(); + break; + case "aspect_ratio": + camera.AspectRatio = xml.ReadElementContentAsFloat(); + break; + case "znear": + camera.ZNear = xml.ReadElementContentAsFloat(); + break; + case "zfar": + camera.ZFar = xml.ReadElementContentAsFloat(); + break; + + default: + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + } + + // + // Materials + // + + private void ReadImage(Image image) + { + //image.Width = ReadNullableIntAttribute("width"); + //image.Height = ReadNullableIntAttribute("height"); + //image.Depth = ReadNullableIntAttribute("depth"); + + ReadAsset(); + + if (xml.IsStartElement("init_from")) + { + string filePath = xml.ReadElementContentAsString(); + + if (!string.IsNullOrEmpty(filePath)) + { + var imageUri = new Uri(baseUrl, filePath); + image.FilePath = imageUri.LocalPath; + } + } + else if (xml.IsStartElement("data")) + { + throw new NotSupportedException("Embedded image data is not supported"); + } + else + { + throw new InvalidDataException(); + } + + ReadExtra(); + } + + private void ReadEffect(Effect effect) + { + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "image": + ReadEntity(images, ReadImage); + break; + case "newparam": + ReadEffectParameterDecl(effect); + break; + case "profile_COMMON": + ReadEffectProfileCommon(effect); + break; + default: + xml.Skip(); + break; + } + } + + ReadExtra(); + } + + private void ReadEffectProfileCommon(Effect effect) + { + xml.ReadStartElement(); + ReadAsset(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "image": + ReadEntity(images, ReadImage); + break; + case "newparam": + ReadEffectParameterDecl(effect); + break; + case "technique": + ReadEffectTechniqueCommon(effect); + break; + default: + xml.Skip(); + break; + } + } + + ReadExtra(); + xml.ReadEndElement(); + } + + private void ReadEffectTechniqueCommon(Effect effect) + { + xml.ReadStartElement(); + ReadAsset(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "image": + ReadEntity(images, ReadImage); + break; + + case "constant": + case "lambert": + case "phong": + case "blinn": + xml.ReadStartElement(); + ReadEffectTechniqueParameters(effect); + xml.ReadEndElement(); + break; + + default: + xml.Skip(); + break; + } + } + + ReadExtra(); + xml.ReadEndElement(); + } + + private void ReadEffectParameterDecl(Effect effect) + { + var parameter = new EffectParameter(); + parameter.Sid = xml.GetAttribute("sid"); + + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "semantic": + parameter.Semantic = xml.ReadElementContentAsString(); + break; + case "float": + parameter.Value = xml.ReadElementContentAsFloat(); + break; + case "float2": + parameter.Value = xml.ReadElementContentAsVector2(); + break; + case "float3": + parameter.Value = xml.ReadElementContentAsVector3(); + break; + case "surface": + parameter.Value = ReadEffectSurface(effect); + break; + case "sampler2D": + parameter.Value = ReadEffectSampler2D(effect); + break; + default: + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + + effect.Parameters.Add(parameter); + } + + private EffectSurface ReadEffectSurface(Effect effect) + { + var surface = new EffectSurface(); + + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "init_from": + BindId(xml.ReadElementContentAsString(), image => { + surface.InitFrom = image; + }); + break; + + default: + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + return surface; + } + + private EffectSampler ReadEffectSampler2D(Effect effect) + { + var sampler = new EffectSampler(); + + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "source": + string surfaceSid = xml.ReadElementContentAsString(); + foreach (var parameter in effect.Parameters) + { + if (parameter.Sid == surfaceSid) + sampler.Surface = parameter.Value as EffectSurface; + } + break; + case "wrap_s": + sampler.WrapS = (EffectSamplerWrap)Enum.Parse(typeof(EffectSamplerWrap), xml.ReadElementContentAsString(), true); + break; + case "wrap_t": + sampler.WrapT = (EffectSamplerWrap)Enum.Parse(typeof(EffectSamplerWrap), xml.ReadElementContentAsString(), true); + break; + default: + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + return sampler; + } + + private void ReadEffectTechniqueParameters(Effect effect) + { + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "emission": + ReadColorEffectParameter(effect, effect.Emission, EffectTextureChannel.Emission); + break; + case "ambient": + ReadColorEffectParameter(effect, effect.Ambient, EffectTextureChannel.Ambient); + break; + case "diffuse": + ReadColorEffectParameter(effect, effect.Diffuse, EffectTextureChannel.Diffuse); + break; + case "specular": + ReadColorEffectParameter(effect, effect.Specular, EffectTextureChannel.Specular); + break; + case "shininess": + ReadFloatEffectParameter(effect.Shininess); + break; + case "reflective": + ReadColorEffectParameter(effect, effect.Reflective, EffectTextureChannel.Reflective); + break; + case "reflectivity": + ReadFloatEffectParameter(effect.Reflectivity); + break; + case "transparent": + ReadColorEffectParameter(effect, effect.Transparent, EffectTextureChannel.Transparent); + break; + case "transparency": + ReadFloatEffectParameter(effect.Transparency); + break; + case "index_of_refraction": + ReadFloatEffectParameter(effect.IndexOfRefraction); + break; + default: + xml.Skip(); + break; + } + } + } + + private void ReadFloatEffectParameter(EffectParameter parameter) + { + xml.ReadStartElement(); + + if (xml.IsStartElement("float")) + { + parameter.Sid = xml.GetAttribute("sid"); + parameter.Value = xml.ReadElementContentAsFloat(); + } + else if (xml.IsStartElement("param")) + { + parameter.Reference = xml.GetAttribute("ref"); + xml.Skip(); + } + + xml.ReadEndElement(); + } + + private void ReadColorEffectParameter(Effect effect, EffectParameter parameter, EffectTextureChannel channel) + { + xml.ReadStartElement(); + + if (xml.IsStartElement("color")) + { + parameter.Sid = xml.GetAttribute("sid"); + parameter.Value = xml.ReadElementContentAsVector4(); + } + else if (xml.IsStartElement("param")) + { + parameter.Sid = null; + parameter.Reference = xml.GetAttribute("ref"); + } + else if (xml.IsStartElement("texture")) + { + parameter.Sid = null; + + string texCoordSymbol = xml.GetAttribute("texcoord"); + string samplerId = xml.GetAttribute("texture"); + xml.Skip(); + + // + // HACK: Maya produces duplicate texture elements, skip them... + // + + while (xml.IsStartElement("texture")) + xml.Skip(); + + EffectSampler sampler = null; + + foreach (var parameterDecl in effect.Parameters) + { + if (parameterDecl.Sid == samplerId) + { + sampler = parameterDecl.Value as EffectSampler; + break; + } + } + + if (sampler == null) + { + info.WriteLine("COLLADA: cannot find sampler {0} in effect {1}, trying to use image directly", samplerId, effect.Name); + + var surface = new EffectSurface(); + sampler = new EffectSampler(surface); + + BindId(samplerId, image => { + surface.InitFrom = image; + }); + } + + var texture = new EffectTexture { + Channel = channel, + TexCoordSemantic = texCoordSymbol, + Sampler = sampler + }; + + parameter.Value = texture; + } + + xml.ReadEndElement(); + } + + private void ReadMaterial(Material material) + { + if (!xml.IsStartElement("instance_effect")) + return; + + BindUrlAttribute("url", effect => { + material.Effect = effect; + }); + + xml.Skip(); + } + + // + // Geometry + // + + private void ReadGeometry(Geometry geometry) + { + if (xml.IsStartElement("mesh")) + { + ReadMesh(geometry); + } + else + { + throw new NotSupportedException(string.Format("Geometry content of type {0} is not supported", xml.LocalName)); + } + } + + // + // Mesh + // + + private void ReadMesh(Geometry geometry) + { + xml.ReadStartElement(); + + while (xml.IsStartElement("source")) + ReadGeometrySource(); + + if (xml.IsStartElement("vertices")) + ReadMeshVertices(geometry); + + while (xml.IsStartElement()) + { + var primitives = ReadMeshPrimitives(geometry); + + if (primitives == null) + break; + + geometry.Primitives.Add(primitives); + } + + ReadExtra(); + xml.ReadEndElement(); + } + + // + // Mesh Data Source + // + + private Source ReadGeometrySource() + { + string id = xml.GetAttribute("id"); + string name = xml.GetAttribute("name"); + + xml.ReadStartElement(); + ReadAsset(); + + var data = ReadFloatArray(); + var source = new Source(data, 1) { + Name = name + }; + + if (xml.IsStartElement("technique_common")) + { + xml.ReadStartElement(); + + if (xml.IsStartElement("accessor")) + { + source.Stride = ReadIntAttribute("stride", 1); + + xml.ReadStartElement(); + + while (xml.IsStartElement("param")) + ReadParam(); + + xml.ReadEndElement(); + } + + xml.ReadEndElement(); + } + + xml.SkipSequence("technique"); + xml.ReadEndElement(); + + AddEntity(id, source); + + return source; + } + + private string ReadParam() + { + string name = xml.GetAttribute("name"); + //string sid = xml.GetAttribute("sid"); + //string type = xml.GetAttribute("type"); + //string semantic = xml.GetAttribute("semantic"); + + xml.Skip(); + + return name; + } + + // + // Mesh Vertices + // + + private void ReadMeshVertices(Geometry mesh) + { + string id = xml.GetAttribute("id"); + + for (xml.ReadStartElement(); xml.IsStartElement("input"); xml.Skip()) + { + var semantic = ReadSemanticAttribute(); + + if (semantic != Semantic.None && semantic != Semantic.Vertex) + { + var input = new Input(); + input.Semantic = semantic; + BindUrlAttribute("source", s => { + input.Source = s; + }); + mesh.Vertices.Add(input); + } + } + + ReadExtra(); + xml.ReadEndElement(); + } + + // + // Mesh Polygons + // + + private MeshPrimitives ReadMeshPrimitives(Geometry mesh) + { + MeshPrimitives primitives; + + int primitiveCount = ReadIntAttribute("count", 0); + int fixedVertexCount = 0; + bool isPolygons = false; + + switch (xml.LocalName) + { + case "lines": + primitives = new MeshPrimitives(MeshPrimitiveType.Lines); + fixedVertexCount = 2; + break; + case "triangles": + primitives = new MeshPrimitives(MeshPrimitiveType.Polygons); + fixedVertexCount = 3; + break; + + case "linestrips": + primitives = new MeshPrimitives(MeshPrimitiveType.LineStrips); + isPolygons = true; + break; + case "trifans": + primitives = new MeshPrimitives(MeshPrimitiveType.TriangleFans); + isPolygons = true; + break; + case "tristrips": + primitives = new MeshPrimitives(MeshPrimitiveType.TriangleStrips); + isPolygons = true; + break; + case "polygons": + primitives = new MeshPrimitives(MeshPrimitiveType.Polygons); + isPolygons = true; + break; + + case "polylist": + primitives = new MeshPrimitives(MeshPrimitiveType.Polygons); + break; + + default: + return null; + } + + primitives.MaterialSymbol = xml.GetAttribute("material"); + + bool vertexFound = false; + + // + // Read the inputs + // + + for (xml.ReadStartElement(); xml.IsStartElement("input"); xml.Skip()) + { + var semantic = ReadSemanticAttribute(); + + if (semantic == Semantic.None) + continue; + + int offset = ReadIntAttribute("offset"); + string sourceId = xml.GetAttribute("source"); + int set = ReadIntAttribute("set", -1); + + if (semantic == Semantic.Vertex) + { + if (vertexFound) + { + error.WriteLine("Duplicate vertex input found"); + continue; + } + + vertexFound = true; + + foreach (var vertexInput in mesh.Vertices) + { + primitives.Inputs.Add(new IndexedInput { + Source = vertexInput.Source, + Offset = offset, + Set = set, + Semantic = vertexInput.Semantic + }); + } + } + else + { + var input = new IndexedInput { + Offset = offset, + Semantic = semantic, + Set = set + }; + + BindUrl(sourceId, s => { + + // + // Ignore inputs with no source data + // + + if (s.Count > 0) + { + input.Source = s; + primitives.Inputs.Add(input); + } + }); + } + } + + if (!vertexFound) + throw new InvalidDataException("no vertex input"); + + // + // Read vertex counts (if availabled and needed) + // + + if (primitiveCount > 0) + primitives.VertexCounts.Capacity = primitiveCount; + + int numIndices = 0; + + while (xml.IsStartElement("vcount")) + { + if (fixedVertexCount != 0 || isPolygons) + { + xml.Skip(); + continue; + } + + foreach (var token in xml.ReadElementContentAsList()) + { + int count = XmlConvert.ToInt32(token); + numIndices += count; + primitives.VertexCounts.Add(count); + } + } + + if (fixedVertexCount != 0) + { + for (int i = 0; i < primitiveCount; i++) + primitives.VertexCounts.Add(fixedVertexCount); + + numIndices = fixedVertexCount * primitiveCount; + } + else if (!isPolygons) + { + if (primitives.VertexCounts.Count == 0) + throw new InvalidDataException("no vcount"); + } + + // + // Read input indices + // 1. Collect all inputs in an array indexed by input offset + // + + var maxOffset = primitives.Inputs.Max(x => x.Offset); + var inputIndices = new List[maxOffset + 1]; + + foreach (var input in primitives.Inputs) + { + List indices = inputIndices[input.Offset]; + + if (indices == null) + { + indices = new List(numIndices); + inputIndices[input.Offset] = indices; + } + } + + // + // 2. Read polygon input indices + // + + if (!isPolygons) + { + while (xml.IsStartElement("p")) + ReadInterleavedInputIndices(inputIndices); + } + else + { + while (xml.IsStartElement()) + { + if (xml.IsStartElement("p")) + { + primitives.VertexCounts.Add(ReadInterleavedInputIndices(inputIndices)); + } + else if (xml.IsStartElement("ph")) + { + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + if (xml.LocalName == "p") + primitives.VertexCounts.Add(ReadInterleavedInputIndices(inputIndices)); + else + xml.Skip(); + } + + xml.ReadEndElement(); + } + else + { + break; + } + } + } + + foreach (var input in primitives.Inputs) + input.Indices.AddRange(inputIndices[input.Offset]); + + ReadExtra(); + xml.ReadEndElement(); + + return primitives; + } + + private int ReadInterleavedInputIndices(List[] inputs) + { + int count = 0; + int offset = 0; + + foreach (string token in xml.ReadElementContentAsList()) + { + var input = inputs[offset++]; + + if (input != null) + input.Add(XmlConvert.ToInt32(token)); + + if (offset >= inputs.Length) + { + offset = 0; + count++; + } + } + + return count; + } + + // + // Scene + // + + private void ReadScene(Scene scene) + { + while (xml.IsStartElement("node")) + ReadEntity(scene.Nodes, ReadNode); + } + + private void ReadNode(Node node) + { + ReadTransforms(node.Transforms); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "node": + ReadEntity(node.Nodes, ReadNode); + break; + + case "instance_geometry": + node.Instances.Add(ReadGeometryInstance()); + break; + + case "instance_light": + node.Instances.Add(ReadLightInstance()); + break; + + case "instance_camera": + node.Instances.Add(ReadCameraInstance()); + break; + + case "instance_node": + node.Instances.Add(ReadNodeInstance()); + break; + + default: + xml.Skip(); + break; + } + } + } + + private void ReadSimpleInstance(Instance instance) + where T : Entity + { + instance.Sid = xml.GetAttribute("sid"); + instance.Name = xml.GetAttribute("name"); + BindUrlAttribute("url", camera => { + instance.Target = camera; + }); + + xml.Skip(); + } + + private NodeInstance ReadNodeInstance() + { + var instance = new NodeInstance(); + ReadSimpleInstance(instance); + return instance; + } + + private CameraInstance ReadCameraInstance() + { + var instance = new CameraInstance(); + ReadSimpleInstance(instance); + return instance; + } + + private LightInstance ReadLightInstance() + { + var instance = new LightInstance(); + ReadSimpleInstance(instance); + return instance; + } + + // + // Node Transforms + // + + private void ReadTransforms(ICollection transforms) + { + while (xml.IsStartElement()) + { + Transform transform = null; + + switch (xml.LocalName) + { + case "matrix": + transform = new TransformMatrix(); + break; + case "rotate": + transform = new TransformRotate(); + break; + case "scale": + transform = new TransformScale(); + break; + case "translate": + transform = new TransformTranslate(); + break; + + case "skew": + case "lookat": + xml.Skip(); + break; + + default: + return; + } + + if (transform != null) + { + transform.Sid = xml.GetAttribute("sid"); + xml.ReadElementContentAsArray(floatConverter, transform.Values); + transforms.Add(transform); + } + } + } + + // + // Instances + // + + private void ReadInstances(ICollection instances) + { + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "instance_geometry": + instances.Add(ReadGeometryInstance()); + break; + + case "instance_camera": + case "instance_controller": + case "instance_light": + case "instance_node": + xml.Skip(); + break; + + default: + return; + } + } + } + + private GeometryInstance ReadGeometryInstance() + { + var instance = new GeometryInstance { + Name = xml.GetAttribute("name"), + Sid = xml.GetAttribute("sid"), + }; + + string url = xml.GetAttribute("url"); + BindUrl(url, geometry => { + instance.Target = geometry; + }); + + if (!xml.SkipEmpty()) + { + xml.ReadStartElement(); + + if (xml.IsStartElement("bind_material")) + ReadBindMaterial(instance, url); + + ReadExtra(); + + xml.ReadEndElement(); + } + + return instance; + } + + private void ReadBindMaterial(GeometryInstance geometryInstance, string geometryUrl) + { + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + if (xml.LocalName != "technique_common") + { + xml.Skip(); + continue; + } + + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + if (xml.LocalName == "instance_material") + ReadMaterialInstance(geometryInstance, geometryUrl); + else + xml.Skip(); + } + + xml.ReadEndElement(); + } + + xml.ReadEndElement(); + } + + private void ReadMaterialInstance(GeometryInstance geometryInstance, string geometryUrl) + { + var instance = new MaterialInstance(); + instance.Symbol = xml.GetAttribute("symbol"); + BindUrlAttribute("target", material => { + instance.Target = material; + }); + geometryInstance.Materials.Add(instance); + + if (xml.SkipEmpty()) + return; + + for (xml.ReadStartElement(); xml.IsStartElement(); xml.Skip()) + { + if (xml.LocalName == "bind") + { + var binding = new MaterialBinding(); + binding.Semantic = xml.GetAttribute("semantic"); + string target = xml.GetAttribute("target"); + + BindId(target, s => { + BindUrl(geometryUrl, g => { + var primitives = g.Primitives.Find(p => p.MaterialSymbol == instance.Symbol); + + if (primitives == null) + return; + + var input = primitives.Inputs.Find(i => i.Source == s); + + if (input == null) + return; + + binding.VertexInput = input; + instance.Bindings.Add(binding); + }); + }); + } + else if (xml.LocalName == "bind_vertex_input") + { + var binding = new MaterialBinding(); + binding.Semantic = xml.GetAttribute("semantic"); + var inputSemantic = ReadSemanticAttribute("input_semantic"); + int inputSet = ReadIntAttribute("input_set", 0); + + BindUrl(geometryUrl, g => { + var primitives = g.Primitives.Find(p => p.MaterialSymbol == instance.Symbol); + + if (primitives == null) + return; + + var input = primitives.Inputs.Find(i => i.Semantic == inputSemantic && i.Set == inputSet); + + if (input == null) + return; + + binding.VertexInput = input; + instance.Bindings.Add(binding); + }); + } + } + + xml.ReadEndElement(); + } + + // + // Animations + // + + private void ReadAnimation(Animation animation) + { + while (xml.IsStartElement("animation")) + ReadEntity(animation.Animations, ReadAnimation); + + while (xml.IsStartElement("source")) + ReadAnimationSource(); + + while (xml.IsStartElement("sampler")) + animation.Samplers.Add(ReadAnimationSampler()); + + while (xml.IsStartElement("channel")) + { + BindAnimationSampler(xml.GetAttribute("source"), xml.GetAttribute("target")); + xml.Skip(); + } + } + + private Source ReadAnimationSource() + { + string id = xml.GetAttribute("id"); + string name = xml.GetAttribute("name"); + + if (string.IsNullOrEmpty(name)) + name = id; + + xml.ReadStartElement(); + + ReadAsset(); + + Source source; + + if (xml.IsStartElement("float_array")) + source = new Source(ReadFloatArray(), 1); + else if (xml.IsStartElement("Name_array")) + source = new Source(ReadNameArray(), 1); + else + throw new NotSupportedException(string.Format("Animation sources of type {0} are not supported", xml.LocalName)); + + source.Name = name; + + if (xml.IsStartElement("technique_common")) + { + xml.ReadStartElement(); + + if (xml.IsStartElement("accessor")) + { + source.Stride = ReadIntAttribute("stride", 1); + + xml.ReadStartElement(); + + while (xml.IsStartElement("param")) + ReadParam(); + + xml.ReadEndElement(); + } + + xml.ReadEndElement(); + } + + xml.SkipSequence("technique"); + xml.ReadEndElement(); + + AddEntity(id, source); + + return source; + } + + private Input ReadAnimationInput() + { + var input = new Input(); + input.Semantic = ReadSemanticAttribute(); + BindUrlAttribute("source", source => { + input.Source = source; + }); + + xml.Skip(); + + return input; + } + + private Sampler ReadAnimationSampler() + { + string id = xml.GetAttribute("id"); + + xml.ReadStartElement(); + + var sampler = new Sampler(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "input": + sampler.Inputs.Add(ReadAnimationInput()); + break; + + default: + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + + AddEntity(id, sampler); + + return sampler; + } + + #region private class TargetPath + + private class TargetPath + { + private string nodeId; + private string[] path; + private string value; + + private TargetPath() + { + } + + public static TargetPath Parse(string text) + { + TargetPath path = new TargetPath(); + List sids = new List(); + + int index = text.IndexOf('/'); + + if (index == -1) + index = text.Length; + + path.nodeId = text.Substring(0, index); + + for (int start = index + 1; start < text.Length; start = index + 1) + { + index = text.IndexOf('/', start); + + if (index == -1) + { + index = text.IndexOf('.', start); + + if (index == -1) + { + sids.Add(text.Substring(start)); + } + else + { + sids.Add(text.Substring(start, index - start)); + path.value = text.Substring(index + 1); + } + + break; + } + + sids.Add(text.Substring(start, index - start)); + } + + if (sids.Count > 0) + path.path = sids.ToArray(); + + return path; + } + + public string NodeId => nodeId; + public string[] Path => path; + public string Value => value; + } + + #endregion + + // + // Lights + // + + private void ReadLight(Light light) + { + if (!xml.IsStartElement("technique_common")) + { + xml.Skip(); + return; + } + + xml.ReadStartElement(); + + if (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "ambient": + light.Type = LightType.Ambient; + break; + + case "directional": + light.Type = LightType.Directional; + break; + + case "point": + light.Type = LightType.Point; + break; + + case "spot": + light.Type = LightType.Spot; + break; + } + + xml.ReadStartElement(); + + light.Color = xml.ReadElementContentAsVector3("color"); + + if (light.Type == LightType.Point || light.Type == LightType.Spot) + { + if (xml.LocalName == "constant_attenuation") + light.ConstantAttenuation = xml.ReadElementContentAsFloat(); + + if (xml.LocalName == "linear_attenuation") + light.LinearAttenuation = xml.ReadElementContentAsFloat(); + + if (light.Type == LightType.Point) + { + light.QuadraticAttenuation = xml.ReadElementContentAsFloat("quadratic_attenuation", string.Empty); + + if (xml.LocalName == "zfar") + light.ZFar = xml.ReadElementContentAsFloat(); + } + else if (light.Type == LightType.Spot) + { + if (xml.LocalName == "quadratic_attenuation") + light.QuadraticAttenuation = xml.ReadElementContentAsFloat(); + + if (xml.LocalName == "falloff_angle") + light.FalloffAngle = xml.ReadElementContentAsFloat(); + + if (xml.LocalName == "falloff_exponent") + light.FalloffExponent = xml.ReadElementContentAsFloat(); + } + } + + xml.ReadEndElement(); + } + + xml.ReadEndElement(); + } + + // + // Scene + // + + private void ReadScene() + { + if (!xml.IsStartElement("scene")) + return; + + xml.ReadStartElement(); + xml.SkipSequence("instance_physics_scene"); + + if (xml.IsStartElement("instance_visual_scene")) + { + BindUrlAttribute("url", scene => { + mainScene = scene; + }); + xml.Skip(); + } + + ReadExtra(); + xml.ReadEndElement(); + } + + // + // Others + // + + private void ReadAsset() + { + if (!xml.IsStartElement("asset")) + return; + + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "up_axis": + upAxis = ReadUpAxis(); + break; + case "contributor": + ReadAssetContributor(); + break; + case "unit": + unit = XmlConvert.ToSingle(xml.GetAttribute("meter")); + xml.Skip(); + break; + default: + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + } + + private void ReadAssetContributor() + { + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + default: + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + } + + private void ReadExtra() + { + while (xml.IsStartElement("extra")) + xml.Skip(); + } + + // + // Arrays + // + + private float[] ReadFloatArray() + { + if (!xml.IsStartElement("float_array")) + return null; + + var id = xml.GetAttribute("id"); + var count = ReadIntAttribute("count"); + var data = new float[count]; + var index = 0; + + foreach (var token in xml.ReadElementContentAsList()) + { + if (index < data.Length) + data[index++] = XmlConvert.ToSingle(token); + } + + return data; + } + + private string[] ReadNameArray() + { + if (!xml.IsStartElement("Name_array")) + return null; + + var id = xml.GetAttribute("id"); + var count = ReadIntAttribute("count"); + var data = new string[count]; + var index = 0; + + foreach (var token in xml.ReadElementContentAsList()) + { + if (index < data.Length) + data[index++] = token; + } + + return data; + } + + // + // Attributes + // + + private int ReadIntAttribute(string name) + { + string text = xml.GetAttribute(name); + + if (string.IsNullOrEmpty(text)) + throw new InvalidDataException(name + " attribute not found"); + + return XmlConvert.ToInt32(text); + } + + private int ReadIntAttribute(string name, int defaultValue) + { + string text = xml.GetAttribute(name); + + if (string.IsNullOrEmpty(text)) + return defaultValue; + + return XmlConvert.ToInt32(text); + } + + private int? ReadNullableIntAttribute(string name) + { + string text = xml.GetAttribute(name); + + if (string.IsNullOrEmpty(text)) + return null; + + return XmlConvert.ToInt32(text); + } + + private Semantic ReadSemanticAttribute() + { + return ReadSemanticAttribute("semantic"); + } + + private Semantic ReadSemanticAttribute(string name) + { + string text = xml.GetAttribute(name); + + switch (text) + { + case "POSITION": + return Semantic.Position; + case "TEXCOORD": + return Semantic.TexCoord; + case "NORMAL": + return Semantic.Normal; + case "COLOR": + return Semantic.Color; + case "VERTEX": + return Semantic.Vertex; + + case "INPUT": + return Semantic.Input; + case "IN_TANGENT": + return Semantic.InTangent; + case "OUT_TANGENT": + return Semantic.OutTangent; + case "INTERPOLATION": + return Semantic.Interpolation; + case "OUTPUT": + return Semantic.Output; + + default: + return Semantic.None; + } + } + + private string[] ReadStringListAttribute(string name) + { + string text = xml.GetAttribute(name); + + if (string.IsNullOrEmpty(text)) + return emptyStrings; + + return text.Split(whiteSpaceChars, StringSplitOptions.RemoveEmptyEntries); + } + + private Axis ReadUpAxis() + { + switch (xml.ReadElementContentAsString()) + { + case "X_UP": + return Axis.X; + case "Z_UP": + return Axis.Z; + default: + return Axis.Y; + } + } + + private void AddEntity(string id, Entity entity) + { + if (string.IsNullOrEmpty(id)) + return; + + if (entities == null) + entities = new Dictionary(); + + if (entities.ContainsKey(id)) + error.WriteLine(string.Format("COLLADA error: duplicate id {0}", id)); + else + entities.Add(id, entity); + + entity.Id = id; + } + + private T GetEntity(string id) where T : Entity + { + Entity result; + + if (entities == null + || string.IsNullOrEmpty(id) + || !entities.TryGetValue(id, out result)) + return null; + + return result as T; + } + + private void BindUrlAttribute(string name, Action action) + where T : Entity + { + BindUrl(xml.GetAttribute(name), action); + } + + private void BindUrl(string url, Action action) + where T : Entity + { + if (string.IsNullOrEmpty(url)) + return; + + if (url[0] != '#') + throw new NotSupportedException(string.Format("External reference '{0}' is not supported", url)); + + BindId(url.Substring(1), action); + } + + private void BindId(string id, Action action) + where T : Entity + { + if (string.IsNullOrEmpty(id)) + return; + + var entity = GetEntity(id); + + if (entity != null) + { + action(entity); + return; + } + + delayedBindActions.Add(delegate { + var entity2 = GetEntity(id); + + if (entity2 != null) + action(entity2); + }); + } + + private void BindAnimationSampler(string sourceId, string targetPath) + { + var path = TargetPath.Parse(targetPath); + + BindUrlAttribute("source", sampler => { + var output = sampler.Inputs.Find(i => i.Semantic == Semantic.Output); + + if (output == null || output.Source == null) + return; + + int stride = output.Source.Stride; + + if (stride != 1) + { + for (int offset = 0; offset < stride; offset++) + { + var newSampler = sampler.Split(offset); + + BindId(path.NodeId, node => { + Transform transform = FindTransform(node, path.Path[0]); + + if (transform != null) + transform.BindAnimation(string.Format(CultureInfo.InvariantCulture, "({0})", offset), newSampler); + }); + } + } + else + { + BindId(path.NodeId, node => { + var transform = FindTransform(node, path.Path[0]); + + if (transform != null) + transform.BindAnimation(path.Value, sampler); + }); + } + }); + } + + private Transform FindTransform(Node node, string sid) + { + return node.Transforms.Find(t => t.Sid == sid); + } + + private void BindNodes(Node node) + { + foreach (var instance in node.Instances.OfType().ToList()) + { + node.Instances.Remove(instance); + + if (instance.Target != node) + node.Nodes.Add(instance.Target); + } + + foreach (var child in node.Nodes) + BindNodes(child); + } + } +} Index: /OniSplit/Dae/IO/DaeWriter.cs =================================================================== --- /OniSplit/Dae/IO/DaeWriter.cs (revision 1114) +++ /OniSplit/Dae/IO/DaeWriter.cs (revision 1114) @@ -0,0 +1,1086 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Globalization; +using System.Text; +using System.Xml; + +namespace Oni.Dae.IO +{ + internal class DaeWriter + { + #region Private data + private XmlWriter xml; + private Scene mainScene; + private WriteVisitor visitor; + private Dictionary writtenSources = new Dictionary(); + #endregion + + #region private class Animation + + private class Animation : Entity + { + public readonly List Sources = new List(); + public readonly List Samplers = new List(); + public readonly List Channels = new List(); + } + + #endregion + #region private class AnimationChannel + + private class AnimationChannel + { + public readonly Sampler Sampler; + public readonly string TargetPath; + + public AnimationChannel(Sampler sampler, string targetPath) + { + this.Sampler = sampler; + this.TargetPath = targetPath; + } + } + + #endregion + #region private class AnimationSource + + private class AnimationSource : Source + { + public readonly string[] Parameters; + + public AnimationSource(float[] data, string[] parameters) + : base(data, parameters.Length) + { + this.Parameters = parameters; + } + + public AnimationSource(string[] data, string[] parameters) + : base(data, parameters.Length) + { + this.Parameters = parameters; + } + } + + #endregion + + #region private class WriteVisitor + + private class WriteVisitor : Visitor + { + private readonly Dictionary entities = new Dictionary(); + private readonly Dictionary ids = new Dictionary(StringComparer.Ordinal); + private readonly Dictionary samplers = new Dictionary(StringComparer.Ordinal); + private readonly Dictionary sources = new Dictionary(StringComparer.Ordinal); + private int uniqueEntityId = 1; + + public readonly List Images = new List(); + public readonly List Effects = new List(); + public readonly List Materials = new List(); + public readonly List Geometries = new List(); + public readonly List Scenes = new List(); + public readonly List Animations = new List(); + public readonly List Cameras = new List(); + + public override void VisitScene(Scene scene) + { + AddEntity(scene); + + base.VisitScene(scene); + } + + public override void VisitNode(Node node) + { + EnsureId(node); + + foreach (var transform in node.Transforms.Where(t => t.HasAnimations)) + { + for (int i = 0; i < transform.Animations.Length; i++) + { + var sampler = transform.Animations[i]; + + if (sampler != null) + AddAnimationChannel(sampler, node, transform, i); + } + } + + base.VisitNode(node); + } + + public override void VisitGeometry(Geometry geometry) + { + AddEntity(geometry); + + string baseId = IdOf(geometry); + + if (baseId.EndsWith("_geometry", StringComparison.Ordinal)) + baseId = baseId.Substring(0, baseId.Length - "_geometry".Length); + + foreach (var input in geometry.Vertices) + EnsureId(input.Source, string.Format(CultureInfo.InvariantCulture, "{0}_{1}", baseId, input.Semantic.ToString().ToLowerInvariant())); + + foreach (var input in geometry.Primitives.SelectMany(p => p.Inputs)) + EnsureId(input.Source, string.Format(CultureInfo.InvariantCulture, "{0}_{1}", baseId, input.Semantic.ToString().ToLowerInvariant())); + + base.VisitGeometry(geometry); + } + + public override void VisitMaterial(Material material) + { + AddEntity(material); + + base.VisitMaterial(material); + } + + public override void VisitEffect(Effect effect) + { + AddEntity(effect); + + base.VisitEffect(effect); + } + + public override void VisitImage(Image image) + { + AddEntity(image); + + base.VisitImage(image); + } + + public override void VisitCamera(Camera camera) + { + AddEntity(camera); + + base.VisitCamera(camera); + } + + private void AddEntity(Scene scene) + { + AddEntity(scene, Scenes); + } + + private void AddEntity(Image image) + { + AddEntity(image, Images); + } + + private void AddEntity(Effect effect) + { + AddEntity(effect, Effects); + } + + private void AddEntity(Material material) + { + AddEntity(material, Materials); + } + + private void AddEntity(Geometry geometry) + { + AddEntity(geometry, Geometries); + } + + private void AddEntity(Animation animation) + { + AddEntity(animation, Animations); + } + + private void AddEntity(Camera camera) + { + AddEntity(camera, Cameras); + } + + private void AddEntity(T entity, ICollection entityCollection) + where T : Entity + { + if (EnsureId(entity)) + entityCollection.Add(entity); + } + + private bool EnsureId(Entity entity) + { + if (entities.ContainsKey(entity)) + return false; + + string name = entity.Name; + string id; + + if (string.IsNullOrEmpty(name)) + { + do + { + id = string.Format(CultureInfo.InvariantCulture, + "unique_{0}", uniqueEntityId++, entity.GetType().Name.ToLowerInvariant()); + } + while (ids.ContainsKey(id)); + } + else + { + if (!ids.ContainsKey(name)) + { + id = name; + } + else + { + id = string.Format(CultureInfo.InvariantCulture, + "{0}_{1}", name, entity.GetType().Name.ToLowerInvariant()); + + while (ids.ContainsKey(id)) + { + id = string.Format(CultureInfo.InvariantCulture, + "{0}_{1}_{2}", name, uniqueEntityId++, entity.GetType().Name.ToLowerInvariant()); + } + } + } + + entities.Add(entity, id); + ids.Add(id, entity); + + return true; + } + + private bool EnsureId(Entity entity, string id) + { + if (entities.ContainsKey(entity)) + return false; + + entities.Add(entity, id); + ids.Add(id, entity); + + return true; + } + + public string IdOf(Entity entity) + { + string id; + entities.TryGetValue(entity, out id); + return id; + } + + public string UrlOf(Entity entity) + { + return string.Format("#{0}", IdOf(entity)); + } + + private void AddAnimationChannel(Sampler sampler, Node node, Transform transform, int valueIndex) + { + Animation animation; + + if (Animations.Count == 0) + { + animation = new Animation(); + Animations.Add(animation); + } + else + { + animation = Animations[0]; + } + + EnsureId(sampler); + + string nodeId = IdOf(node); + string samplerId = IdOf(sampler); + string valueName = transform.ValueIndexToValueName(valueIndex); + Sampler valueSampler; + + if (!samplers.TryGetValue(samplerId + valueName, out valueSampler)) + { + valueSampler = new Sampler(); + EnsureId(valueSampler, string.Format("{0}_{1}_{2}", IdOf(node), transform.Sid, valueName)); + animation.Samplers.Add(valueSampler); + + foreach (var input in sampler.Inputs) + { + var source = input.Source; + EnsureId(source); + + string sourceId = IdOf(source) + (input.Semantic == Semantic.Output ? valueName : ""); + + if (!sources.TryGetValue(sourceId, out source)) + { + source = input.Source; + + switch (input.Semantic) + { + case Semantic.Input: + source = new AnimationSource(source.FloatData, new[] { "TIME" }); + break; + case Semantic.Output: + source = new AnimationSource(source.FloatData, new[] { valueName }); + break; + case Semantic.Interpolation: + source = new AnimationSource(source.NameData, new[] { "INTERPOLATION" }); + break; + case Semantic.OutTangent: + case Semantic.InTangent: + source = new AnimationSource(source.FloatData, new[] { "X", "Y" }); + break; + default: + throw new NotSupportedException(string.Format("Invalid semantic {0} for animation input", input.Semantic)); + } + + sources.Add(sourceId, source); + + EnsureId(source, string.Format(CultureInfo.InvariantCulture, "{0}_{1}", IdOf(valueSampler), input.Semantic.ToString().ToLowerInvariant())); + animation.Sources.Add(source); + } + + valueSampler.Inputs.Add(new Input(input.Semantic, source)); + } + } + + animation.Channels.Add(new AnimationChannel( + valueSampler, + string.Format(CultureInfo.InvariantCulture, "{0}/{1}.{2}", IdOf(node), transform.Sid, valueName))); + } + } + + #endregion + + public static void WriteFile(string filePath, Scene scene) + { + var writer = new DaeWriter(); + writer.visitor = new WriteVisitor(); + writer.visitor.VisitScene(scene); + writer.mainScene = scene; + + var settings = new XmlWriterSettings { + CloseOutput = true, + ConformanceLevel = ConformanceLevel.Document, + Encoding = Encoding.UTF8, + Indent = true, + IndentChars = "\t" + }; + + //AxisConverter.Convert(scene, Axis.Y, Axis.Z); + + using (var stream = File.Create(filePath)) + using (writer.xml = XmlWriter.Create(stream, settings)) + writer.WriteRoot(); + } + + private void WriteRoot() + { + WriteCollada(); + + WriteLibrary("library_cameras", visitor.Cameras, WriteCamera); + WriteLibrary("library_images", visitor.Images, WriteImage); + WriteLibrary("library_effects", visitor.Effects, WriteEffect); + WriteLibrary("library_materials", visitor.Materials, WriteMaterial); + WriteLibrary("library_geometries", visitor.Geometries, WriteGeometry); + WriteLibrary("library_visual_scenes", visitor.Scenes, WriteScene); + WriteLibrary("library_animations", visitor.Animations, WriteAnimation); + + WriteScene(); + } + + private void WriteCollada() + { + xml.WriteStartDocument(); + xml.WriteStartElement("COLLADA", "http://www.collada.org/2005/11/COLLADASchema"); + xml.WriteAttributeString("version", "1.4.0"); + + xml.WriteStartElement("asset"); + xml.WriteStartElement("contributor"); + //xml.WriteElementString("author", "OniSplit"); + xml.WriteElementString("authoring_tool", string.Format(CultureInfo.InvariantCulture, "OniSplit v{0}", Utils.Version)); + xml.WriteEndElement(); + + xml.WriteStartElement("unit"); + xml.WriteAttributeString("meter", "0.1"); + xml.WriteAttributeString("name", "decimeter"); + xml.WriteEndElement(); + xml.WriteElementString("up_axis", "Y_UP"); + xml.WriteEndElement(); + } + + private void WriteLibrary(string name, ICollection library, Action entityWriter) + { + if (library.Count == 0) + return; + + xml.WriteStartElement(name); + + foreach (T entity in library) + entityWriter(entity); + + xml.WriteEndElement(); + } + + private void WriteScene() + { + xml.WriteStartElement("scene"); + xml.WriteStartElement("instance_visual_scene"); + xml.WriteAttributeString("url", visitor.UrlOf(mainScene)); + xml.WriteEndElement(); + xml.WriteEndElement(); + } + + private void WriteImage(Image image) + { + BeginEntity("image", image); + + string imageUrl; + + if (Path.IsPathRooted(image.FilePath)) + imageUrl = "file:///" + image.FilePath.Replace('\\', '/'); + else + imageUrl = image.FilePath.Replace('\\', '/'); + + xml.WriteElementString("init_from", imageUrl); + + EndEntity(); + } + + private void WriteEffect(Effect effect) + { + BeginEntity("effect", effect); + WriteEffectCommonProfile(effect); + EndEntity(); + } + + private void WriteEffectCommonProfile(Effect effect) + { + xml.WriteStartElement("profile_COMMON"); + + foreach (var parameter in effect.Parameters) + WriteEffectParameter(parameter); + + WriteEffectTechnique(effect); + + xml.WriteEndElement(); + } + + private void WriteEffectParameter(EffectParameter parameter) + { + xml.WriteStartElement("newparam"); + xml.WriteAttributeString("sid", parameter.Sid); + + if (!string.IsNullOrEmpty(parameter.Semantic)) + { + xml.WriteStartElement("semantic"); + xml.WriteString(parameter.Semantic); + xml.WriteEndElement(); + } + + if (parameter.Value is float) + { + float value = (float)parameter.Value; + xml.WriteElementString("float", + XmlConvert.ToString(value)); + } + else if (parameter.Value is Vector2) + { + var value = (Vector2)parameter.Value; + xml.WriteElementString("float2", string.Format("{0} {1}", + XmlConvert.ToString(value.X), XmlConvert.ToString(value.Y))); + } + else if (parameter.Value is Vector3) + { + var value = (Vector3)parameter.Value; + xml.WriteElementString("float3", string.Format("{0} {1} {3}", + XmlConvert.ToString(value.X), XmlConvert.ToString(value.Y), XmlConvert.ToString(value.Z))); + } + else if (parameter.Value is EffectSurface) + { + var surface = (EffectSurface)parameter.Value; + xml.WriteStartElement("surface"); + xml.WriteAttributeString("type", "2D"); + xml.WriteElementString("init_from", visitor.IdOf(surface.InitFrom)); + xml.WriteEndElement(); + } + else if (parameter.Value is EffectSampler) + { + var sampler = (EffectSampler)parameter.Value; + xml.WriteStartElement("sampler2D"); + xml.WriteStartElement("source"); + xml.WriteString(sampler.Surface.DeclaringParameter.Sid); + xml.WriteEndElement(); + + if (sampler.MinFilter != EffectSamplerFilter.None) + xml.WriteElementString("minfilter", sampler.MinFilter.ToString().ToUpperInvariant()); + + if (sampler.MagFilter != EffectSamplerFilter.None) + xml.WriteElementString("magfilter", sampler.MagFilter.ToString().ToUpperInvariant()); + + if (sampler.MipFilter != EffectSamplerFilter.None) + xml.WriteElementString("mipfilter", sampler.MipFilter.ToString().ToUpperInvariant()); + + xml.WriteEndElement(); + } + + xml.WriteEndElement(); + } + + private void WriteEffectTechnique(Effect effect) + { + xml.WriteStartElement("technique"); + xml.WriteStartElement("phong"); + + //WriteEffectTechniqueProperty("emission", effect.Emission); + + WriteEffectTechniqueProperty("ambient", effect.Ambient); + WriteEffectTechniqueProperty("diffuse", effect.Diffuse); + WriteEffectTechniqueProperty("specular", effect.Specular); + + //WriteEffectTechniqueProperty("shininess", effect.Shininess); + //WriteEffectTechniqueProperty("reflective", effect.Reflective); + //WriteEffectTechniqueProperty("reflectivity", effect.Reflectivity); + + WriteEffectTechniqueProperty("transparent", effect.Transparent); + + //WriteEffectTechniqueProperty("transparency", effect.Transparency); + //WriteEffectTechniqueProperty("index_of_refraction", effect.IndexOfRefraction); + + xml.WriteEndElement(); + xml.WriteEndElement(); + } + + private void WriteEffectTechniqueProperty(string name, EffectParameter value) + { + bool isTransparent = name == "transparent"; + + if (isTransparent && value.Value == null) + return; + + xml.WriteStartElement(name); + + if (isTransparent) + xml.WriteAttributeString("opaque", "A_ONE"); + + if (value.Reference != null) + { + xml.WriteStartElement("param"); + xml.WriteString(value.Reference); + xml.WriteEndElement(); + } + else if (value.Value is float) + { + float flt = (float)value.Value; + xml.WriteStartElement("float"); + xml.WriteAttributeString("sid", value.Sid); + xml.WriteString(XmlConvert.ToString(flt)); + xml.WriteEndElement(); + } + else if (value.Value is Vector4) + { + var color = (Vector4)value.Value; + xml.WriteStartElement("color"); + xml.WriteAttributeString("sid", value.Sid); + xml.WriteString(string.Format(CultureInfo.InvariantCulture, "{0} {1} {2} {3}", + XmlConvert.ToString(color.X), XmlConvert.ToString(color.Y), XmlConvert.ToString(color.Z), XmlConvert.ToString(color.W))); + xml.WriteEndElement(); + } + else if (value.Value is EffectTexture) + { + var texture = (EffectTexture)value.Value; + xml.WriteStartElement("texture"); + xml.WriteAttributeString("texture", texture.Sampler.Owner.Sid); + xml.WriteAttributeString("texcoord", texture.TexCoordSemantic); + xml.WriteEndElement(); + } + + xml.WriteEndElement(); + } + + private void WriteMaterial(Material matrial) + { + BeginEntity("material", matrial); + + xml.WriteStartElement("instance_effect"); + xml.WriteAttributeString("url", visitor.UrlOf(matrial.Effect)); + xml.WriteEndElement(); + + EndEntity(); + } + + private void WriteGeometry(Geometry geometry) + { + BeginEntity("geometry", geometry); + + xml.WriteStartElement("mesh"); + + WriteGeometrySources(geometry); + WriteGeometryVertices(geometry); + + foreach (var primitives in geometry.Primitives) + WriteGeometryPrimitives(geometry, primitives); + + xml.WriteEndElement(); + + EndEntity(); + } + + private void WriteGeometrySources(Geometry geometry) + { + var sources = new Dictionary>(); + + foreach (var primitives in geometry.Primitives) + { + foreach (var input in primitives.Inputs) + { + List uses; + + if (!sources.TryGetValue(input.Source, out uses)) + { + uses = new List(); + sources.Add(input.Source, uses); + } + + if (!uses.Contains(input.Semantic)) + uses.Add(input.Semantic); + } + } + + foreach (var pair in sources) + { + foreach (var semantic in pair.Value) + WriteSource(pair.Key, semantic); + } + } + + private void WriteGeometryVertices(Geometry geometry) + { + string baseId = visitor.IdOf(geometry); + + if (baseId.EndsWith("_geometry", StringComparison.Ordinal)) + baseId = baseId.Substring(0, baseId.Length - "_geometry".Length); + + xml.WriteStartElement("vertices"); + xml.WriteAttributeString("id", baseId + "_vertices"); + + foreach (var input in geometry.Vertices) + { + xml.WriteStartElement("input"); + WriteSemanticAttribute("semantic", input.Semantic); + xml.WriteAttributeString("source", visitor.UrlOf(input.Source)); + xml.WriteEndElement(); + } + + xml.WriteEndElement(); + } + + private void WriteGeometryPrimitives(Geometry geometry, MeshPrimitives primitives) + { + switch (primitives.PrimitiveType) + { + case MeshPrimitiveType.Lines: + case MeshPrimitiveType.LineStrips: + case MeshPrimitiveType.TriangleFans: + case MeshPrimitiveType.TriangleStrips: + throw new NotSupportedException(string.Format("Writing {0} is not supported", primitives.PrimitiveType)); + } + + bool trianglesOnly = !primitives.VertexCounts.Exists(x => x != 3); + + if (!trianglesOnly) + xml.WriteStartElement("polylist"); + else + xml.WriteStartElement("triangles"); + + xml.WriteAttributeString("count", XmlConvert.ToString(primitives.VertexCounts.Count)); + + if (!string.IsNullOrEmpty(primitives.MaterialSymbol)) + xml.WriteAttributeString("material", primitives.MaterialSymbol); + + int offset = 0; + bool vertexInputWritten = false; + + var inputs = new List(); + + string baseUrl = visitor.UrlOf(geometry); + + if (baseUrl.EndsWith("_geometry", StringComparison.Ordinal)) + baseUrl = baseUrl.Substring(0, baseUrl.Length - "_geometry".Length); + + foreach (var input in primitives.Inputs) + { + if (geometry.Vertices.Any(x => x.Source == input.Source)) + { + if (!vertexInputWritten) + { + inputs.Add(input); + + xml.WriteStartElement("input"); + xml.WriteAttributeString("semantic", "VERTEX"); + xml.WriteAttributeString("source", baseUrl + "_vertices"); + xml.WriteAttributeString("offset", XmlConvert.ToString(offset++)); + xml.WriteEndElement(); + } + + vertexInputWritten = true; + } + else + { + inputs.Add(input); + + xml.WriteStartElement("input"); + WriteSemanticAttribute("semantic", input.Semantic); + xml.WriteAttributeString("source", visitor.UrlOf(input.Source)); + xml.WriteAttributeString("offset", XmlConvert.ToString(offset++)); + + if (input.Set != 0) + xml.WriteAttributeString("set", XmlConvert.ToString(input.Set)); + + xml.WriteEndElement(); + } + } + + if (!trianglesOnly) + { + xml.WriteStartElement("vcount"); + xml.WriteWhitespace("\n"); + + int vertexCount = 0; + int c = 0; + + foreach (int i in primitives.VertexCounts) + { + xml.WriteString(XmlConvert.ToString(i) + " "); + vertexCount += i; + + c++; + + if (c == 32) + { + xml.WriteWhitespace("\n"); + c = 0; + } + } + + xml.WriteEndElement(); + } + + xml.WriteStartElement("p"); + xml.WriteWhitespace("\n"); + + int polygonStartIndex = 0; + + foreach (int vertexCount in primitives.VertexCounts) + { + for (int index = 0; index < vertexCount; index++) + { + foreach (var input in inputs) + { + xml.WriteString(XmlConvert.ToString(input.Indices[polygonStartIndex + index])); + + if (input != inputs.Last() || index != vertexCount - 1) + xml.WriteWhitespace(" "); + } + } + + xml.WriteWhitespace("\n"); + polygonStartIndex += vertexCount; + } + + xml.WriteEndElement(); + + xml.WriteEndElement(); + } + + private void WriteScene(Scene scene) + { + BeginEntity("visual_scene", scene); + + foreach (var node in scene.Nodes) + WriteSceneNode(node); + + EndEntity(); + } + + private void WriteSceneNode(Node node) + { + BeginEntity("node", node); + + foreach (var transform in node.Transforms) + WriteNodeTransform(transform); + + foreach (var instance in node.Instances) + { + if (instance is GeometryInstance) + WriteGeometryInstance((GeometryInstance)instance); + else if (instance is CameraInstance) + WriteCameraInstance((CameraInstance)instance); + } + + foreach (var child in node.Nodes) + WriteSceneNode(child); + + EndEntity(); + } + + private void WriteNodeTransform(Transform transform) + { + string type; + + if (transform is TransformTranslate) + type = "translate"; + else if (transform is TransformRotate) + type = "rotate"; + else if (transform is TransformScale) + type = "scale"; + else + type = "matrix"; + + xml.WriteStartElement(type); + + if (!string.IsNullOrEmpty(transform.Sid)) + xml.WriteAttributeString("sid", transform.Sid); + + var values = new StringBuilder(transform.Values.Length * 16); + + foreach (float value in transform.Values) + values.AppendFormat(CultureInfo.InvariantCulture, "{0:f6} ", value); + + if (values.Length > 0) + values.Length--; + + xml.WriteValue(values.ToString()); + + xml.WriteEndElement(); + } + + private void WriteCameraInstance(CameraInstance instance) + { + xml.WriteStartElement("instance_camera"); + xml.WriteAttributeString("url", visitor.UrlOf(instance.Target)); + xml.WriteEndElement(); + } + + private void WriteGeometryInstance(GeometryInstance instance) + { + xml.WriteStartElement("instance_geometry"); + xml.WriteAttributeString("url", visitor.UrlOf(instance.Target)); + + if (instance.Materials.Count > 0) + { + xml.WriteStartElement("bind_material"); + xml.WriteStartElement("technique_common"); + + foreach (var matInstance in instance.Materials) + WriteMaterialInstance(matInstance); + + xml.WriteEndElement(); + xml.WriteEndElement(); + } + + xml.WriteEndElement(); + } + + private void WriteMaterialInstance(MaterialInstance matInstance) + { + xml.WriteStartElement("instance_material"); + xml.WriteAttributeString("symbol", matInstance.Symbol); + xml.WriteAttributeString("target", visitor.UrlOf(matInstance.Target)); + + foreach (var binding in matInstance.Bindings) + { + xml.WriteStartElement("bind_vertex_input"); + xml.WriteAttributeString("semantic", binding.Semantic); + WriteSemanticAttribute("input_semantic", binding.VertexInput.Semantic); + xml.WriteAttributeString("input_set", XmlConvert.ToString(binding.VertexInput.Set)); + xml.WriteEndElement(); + } + + xml.WriteEndElement(); + } + + private void WriteAnimation(Animation animation) + { + BeginEntity("animation", animation); + + foreach (var source in animation.Sources) + WriteSource(source, Semantic.None); + + foreach (var sampler in animation.Samplers) + WriteAnimationSampler(animation, sampler); + + foreach (var channel in animation.Channels) + WriteAnimationChannel(channel); + + EndEntity(); + } + + private void WriteAnimationSampler(Animation animation, Sampler sampler) + { + xml.WriteStartElement("sampler"); + xml.WriteAttributeString("id", visitor.IdOf(sampler)); + + foreach (var input in sampler.Inputs) + { + xml.WriteStartElement("input"); + WriteSemanticAttribute("semantic", input.Semantic); + xml.WriteAttributeString("source", visitor.UrlOf(input.Source)); + xml.WriteEndElement(); + } + + xml.WriteEndElement(); + } + + private void WriteAnimationChannel(AnimationChannel channel) + { + xml.WriteStartElement("channel"); + xml.WriteAttributeString("source", visitor.UrlOf(channel.Sampler)); + xml.WriteAttributeString("target", channel.TargetPath); + xml.WriteEndElement(); + } + + private void BeginEntity(string name, Entity entity) + { + xml.WriteStartElement(name); + + string id = visitor.IdOf(entity); + + if (!string.IsNullOrEmpty(id)) + xml.WriteAttributeString("id", id); + + //if (!String.IsNullOrEmpty(entity.Name)) + // xml.WriteAttributeString("name", entity.Name); + } + + private void EndEntity() + { + xml.WriteEndElement(); + } + + private void WriteSource(Source source, Semantic semantic) + { + if (writtenSources.ContainsKey(source)) + return; + + string sourceId = visitor.IdOf(source); + + writtenSources.Add(source, sourceId); + + var animationSource = source as AnimationSource; + + if (animationSource != null) + { + if (source.FloatData != null) + WriteSource(sourceId, source.FloatData, XmlConvert.ToString, source.Stride, animationSource.Parameters); + else + WriteSource(sourceId, source.NameData, x => x, source.Stride, animationSource.Parameters); + + return; + } + + switch (semantic) + { + case Semantic.Position: + case Semantic.Normal: + WriteSource(sourceId, source.FloatData, XmlConvert.ToString, source.Stride, new[] { "X", "Y", "Z" }); + break; + + case Semantic.TexCoord: + WriteSource(sourceId, source.FloatData, XmlConvert.ToString, source.Stride, new[] { "S", "T" }); + break; + + case Semantic.Color: + if (source.Stride == 4) + WriteSource(sourceId, source.FloatData, XmlConvert.ToString, source.Stride, new[] { "R", "G", "B", "A" }); + else + WriteSource(sourceId, source.FloatData, XmlConvert.ToString, source.Stride, new[] { "R", "G", "B" }); + break; + + case Semantic.Input: + WriteSource(sourceId, source.FloatData, XmlConvert.ToString, source.Stride, new[] { "TIME" }); + return; + + case Semantic.Output: + WriteSource(sourceId, source.FloatData, XmlConvert.ToString, source.Stride, new[] { "VALUE" }); + return; + + case Semantic.Interpolation: + WriteSource(sourceId, source.NameData, x => x, source.Stride, new[] { "INTERPOLATION" }); + return; + + case Semantic.InTangent: + case Semantic.OutTangent: + WriteSource(sourceId, source.FloatData, XmlConvert.ToString, source.Stride, new[] { "X", "Y" }); + break; + + default: + throw new NotSupportedException(string.Format("Sources with semantic {0} are not supported", semantic)); + } + } + + private void WriteSource(string sourceId, T[] data, Func toString, int stride, string[] paramNames) + { + string arrayId = sourceId + "_array"; + string type = null; + + if (typeof(T) == typeof(float)) + type = "float"; + else if (typeof(T) == typeof(string)) + type = "Name"; + + xml.WriteStartElement("source"); + xml.WriteAttributeString("id", sourceId); + + xml.WriteStartElement(type + "_array"); + xml.WriteAttributeString("id", arrayId); + xml.WriteAttributeString("count", XmlConvert.ToString(data.Length)); + xml.WriteWhitespace("\n"); + + int valuesPerLine = (stride == 1) ? 10 : stride; + + for (int i = 0; i < data.Length; i++) + { + xml.WriteString(toString(data[i])); + + if (i != data.Length - 1) + { + if (i % valuesPerLine == valuesPerLine - 1) + xml.WriteWhitespace("\n"); + else + xml.WriteWhitespace(" "); + } + } + + xml.WriteEndElement(); + + xml.WriteStartElement("technique_common"); + WriteSourceAccessor(arrayId, data.Length / stride, stride, type, paramNames); + xml.WriteEndElement(); + + xml.WriteEndElement(); + } + + private void WriteSourceAccessor(string arrayId, int count, int stride, string type, string[] paramNames) + { + xml.WriteStartElement("accessor"); + xml.WriteAttributeString("source", "#" + arrayId); + xml.WriteAttributeString("count", XmlConvert.ToString(count)); + xml.WriteAttributeString("stride", XmlConvert.ToString(stride)); + + for (int i = 0; i < stride; i++) + { + xml.WriteStartElement("param"); + xml.WriteAttributeString("type", type); + xml.WriteAttributeString("name", paramNames[i]); + xml.WriteEndElement(); + } + + xml.WriteEndElement(); + } + + private void WriteSemanticAttribute(string name, Semantic semantic) + { + xml.WriteAttributeString(name, semantic.ToString().ToUpperInvariant()); + } + + private void WriteCamera(Camera camera) + { + BeginEntity("camera", camera); + + xml.WriteStartElement("optics"); + xml.WriteStartElement("technique_common"); + xml.WriteStartElement("perspective"); + xml.WriteElementString("xfov", XmlConvert.ToString(camera.XFov)); + xml.WriteElementString("aspect_ratio", XmlConvert.ToString(camera.AspectRatio)); + xml.WriteElementString("znear", XmlConvert.ToString(camera.ZNear)); + xml.WriteElementString("zfar", XmlConvert.ToString(camera.ZFar)); + xml.WriteEndElement(); + xml.WriteEndElement(); + xml.WriteEndElement(); + + EndEntity(); + } + } +} Index: /OniSplit/Dae/IO/ObjReader.cs =================================================================== --- /OniSplit/Dae/IO/ObjReader.cs (revision 1114) +++ /OniSplit/Dae/IO/ObjReader.cs (revision 1114) @@ -0,0 +1,552 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; + +namespace Oni.Dae.IO +{ + internal class ObjReader + { + private struct ObjVertex : IEquatable + { + public int PointIndex; + public int TexCoordIndex; + public int NormalIndex; + + public ObjVertex(int pointIndex, int uvIndex, int normalIndex) + { + PointIndex = pointIndex; + TexCoordIndex = uvIndex; + NormalIndex = normalIndex; + } + + public static bool operator ==(ObjVertex v1, ObjVertex v2) => + v1.PointIndex == v2.PointIndex + && v1.TexCoordIndex == v2.TexCoordIndex + && v1.NormalIndex == v2.NormalIndex; + + public static bool operator !=(ObjVertex v1, ObjVertex v2) => + v1.PointIndex != v2.PointIndex + || v1.TexCoordIndex != v2.TexCoordIndex + || v1.NormalIndex != v2.NormalIndex; + + public bool Equals(ObjVertex v) => this == v; + public override bool Equals(object obj) => obj is ObjVertex && Equals((ObjVertex)obj); + public override int GetHashCode() => PointIndex ^ TexCoordIndex ^ NormalIndex; + } + + private class ObjFace + { + public string ObjectName; + public string[] GroupsNames; + public ObjVertex[] Vertices; + } + + private class ObjMaterial + { + private readonly string name; + private string textureFilePath; + private Material material; + + public ObjMaterial(string name) + { + this.name = name; + } + + public string Name => name; + + public string TextureFilePath + { + get { return textureFilePath; } + set { textureFilePath = value; } + } + + public Material Material + { + get + { + if (material == null && TextureFilePath != null) + CreateMaterial(); + + return material; + } + } + + private void CreateMaterial() + { + var image = new Image + { + FilePath = TextureFilePath, + Name = name + "_img" + }; + + var effectSurface = new EffectSurface(image); + var effectSampler = new EffectSampler(effectSurface); + var effectTexture = new EffectTexture + { + Sampler = effectSampler, + Channel = EffectTextureChannel.Diffuse, + TexCoordSemantic = "diffuse_TEXCOORD" + }; + + material = new Material + { + Id = name, + Name = name, + Effect = new Effect + { + Id = name + "_fx", + DiffuseValue = effectTexture, + Parameters = { + new EffectParameter("surface", effectSurface), + new EffectParameter("sampler", effectSampler) + } + } + }; + } + } + + private class ObjPrimitives + { + public ObjMaterial Material; + public readonly List Faces = new List(4); + } + + #region Private data + private static readonly string[] emptyStrings = new string[0]; + private static readonly char[] whiteSpaceChars = new char[] { ' ', '\t' }; + private static readonly char[] vertexSeparator = new char[] { '/' }; + + private Scene mainScene; + + private readonly List points = new List(); + private readonly List texCoords = new List(); + private readonly List normals = new List(); + + private int pointCount; + private int normalCount; + private int texCoordCount; + + private readonly Dictionary pointIndex = new Dictionary(); + private readonly Dictionary normalIndex = new Dictionary(); + private readonly Dictionary texCoordIndex = new Dictionary(); + private readonly List pointRemap = new List(); + private readonly List normalRemap = new List(); + private readonly List texCoordRemap = new List(); + + private readonly Dictionary materials = new Dictionary(StringComparer.Ordinal); + + private string currentObjectName; + private string[] currentGroupNames; + private readonly List primitives = new List(); + private ObjPrimitives currentPrimitives; + #endregion + + public static Scene ReadFile(string filePath) + { + var reader = new ObjReader(); + reader.ReadObjFile(filePath); + reader.ImportObjects(); + return reader.mainScene; + } + + private void ReadObjFile(string filePath) + { + mainScene = new Scene(); + + foreach (string line in ReadLines(filePath)) + { + var tokens = line.Split(whiteSpaceChars, StringSplitOptions.RemoveEmptyEntries); + + switch (tokens[0]) + { + case "o": + ReadObject(tokens); + break; + + case "g": + ReadGroup(tokens); + break; + + case "v": + ReadPoint(tokens); + break; + + case "vn": + ReadNormal(tokens); + break; + + case "vt": + ReadTexCoord(tokens); + break; + + case "f": + case "fo": + ReadFace(tokens); + break; + + case "mtllib": + ReadMtlLib(filePath, tokens); + break; + + case "usemtl": + ReadUseMtl(tokens); + break; + } + } + } + + private void ReadPoint(string[] tokens) + { + var point = new Vector3( + float.Parse(tokens[1], CultureInfo.InvariantCulture), + float.Parse(tokens[2], CultureInfo.InvariantCulture), + float.Parse(tokens[3], CultureInfo.InvariantCulture)); + + AddPoint(point); + + pointCount++; + } + + private void AddPoint(Vector3 point) + { + int newIndex; + + if (pointIndex.TryGetValue(point, out newIndex)) + { + pointRemap.Add(newIndex); + } + else + { + pointRemap.Add(points.Count); + pointIndex.Add(point, points.Count); + points.Add(point); + } + } + + private void ReadNormal(string[] tokens) + { + var normal = new Vector3( + float.Parse(tokens[1], CultureInfo.InvariantCulture), + float.Parse(tokens[2], CultureInfo.InvariantCulture), + float.Parse(tokens[3], CultureInfo.InvariantCulture)); + + AddNormal(normal); + + normalCount++; + } + + private void AddNormal(Vector3 normal) + { + int newIndex; + + if (normalIndex.TryGetValue(normal, out newIndex)) + { + normalRemap.Add(newIndex); + } + else + { + normalRemap.Add(normals.Count); + normalIndex.Add(normal, normals.Count); + normals.Add(normal); + } + } + + private void ReadTexCoord(string[] tokens) + { + var texCoord = new Vector2( + float.Parse(tokens[1], CultureInfo.InvariantCulture), + 1.0f - float.Parse(tokens[2], CultureInfo.InvariantCulture)); + + AddTexCoord(texCoord); + + texCoordCount++; + } + + private void AddTexCoord(Vector2 texCoord) + { + int newIndex; + + if (texCoordIndex.TryGetValue(texCoord, out newIndex)) + { + texCoordRemap.Add(newIndex); + } + else + { + texCoordRemap.Add(texCoords.Count); + texCoordIndex.Add(texCoord, texCoords.Count); + texCoords.Add(texCoord); + } + } + + private void ReadFace(string[] tokens) + { + var faceVertices = ReadVertices(tokens); + + if (currentPrimitives == null) + ReadUseMtl(emptyStrings); + + currentPrimitives.Faces.Add(new ObjFace + { + ObjectName = currentObjectName, + GroupsNames = currentGroupNames, + Vertices = faceVertices + }); + } + + private ObjVertex[] ReadVertices(string[] tokens) + { + var vertices = new ObjVertex[tokens.Length - 1]; + + for (int i = 0; i < vertices.Length; i++) + { + // + // Read a point/texture/normal index pair + // + + var indices = tokens[i + 1].Split(vertexSeparator); + + if (indices.Length == 0 || indices.Length > 3) + throw new InvalidDataException(); + + // + // Extract indices from file: 0 means "not specified" + // + + int pointIndex = int.Parse(indices[0], CultureInfo.InvariantCulture); + int texCoordIndex = (indices.Length > 1 && indices[1].Length > 0) ? int.Parse(indices[1], CultureInfo.InvariantCulture) : 0; + int normalIndex = (indices.Length > 2 && indices[2].Length > 0) ? int.Parse(indices[2], CultureInfo.InvariantCulture) : 0; + + // + // Adjust for negative indices + // + + if (pointIndex < 0) + pointIndex = pointCount + pointIndex + 1; + + if (texCoordIndex < 0) + texCoordIndex = texCoordCount + texCoordIndex + 1; + + if (normalIndex < 0) + normalIndex = normalCount + normalIndex + 1; + + // + // Convert indices to internal representation: range 0..n and -1 means "not specified". + // + + pointIndex = pointIndex - 1; + texCoordIndex = texCoordIndex - 1; + normalIndex = normalIndex - 1; + + // + // Remap indices + // + + pointIndex = pointRemap[pointIndex]; + + if (texCoordIndex < 0 || texCoordRemap.Count <= texCoordIndex) + texCoordIndex = -1; + else + texCoordIndex = texCoordRemap[texCoordIndex]; + + if (normalIndex < 0 || normalRemap.Count <= normalIndex) + normalIndex = -1; + else + normalIndex = normalRemap[normalIndex]; + + vertices[i] = new ObjVertex + { + PointIndex = pointIndex, + TexCoordIndex = texCoordIndex, + NormalIndex = normalIndex + }; + } + + return vertices; + } + + private void ReadObject(string[] tokens) + { + currentObjectName = tokens[1]; + } + + private void ReadGroup(string[] tokens) + { + currentGroupNames = tokens; + } + + private void ReadUseMtl(string[] tokens) + { + currentPrimitives = new ObjPrimitives(); + + if (tokens.Length > 0) + materials.TryGetValue(tokens[1], out currentPrimitives.Material); + + primitives.Add(currentPrimitives); + } + + private void ReadMtlLib(string objFilePath, string[] tokens) + { + string materialLibraryFilePath = tokens[1]; + + if (Path.GetExtension(materialLibraryFilePath).Length == 0) + materialLibraryFilePath += ".mtl"; + + var dirPath = Path.GetDirectoryName(objFilePath); + var mtlFilePath = Path.Combine(dirPath, materialLibraryFilePath); + + if (!File.Exists(mtlFilePath)) + { + Console.Error.WriteLine("Material file {0} does not exist", mtlFilePath); + return; + } + + ReadMtlFile(mtlFilePath); + } + + private void ReadMtlFile(string filePath) + { + var dirPath = Path.GetDirectoryName(filePath); + + ObjMaterial currentMaterial = null; + + foreach (string line in ReadLines(filePath)) + { + var tokens = line.Split(whiteSpaceChars, StringSplitOptions.RemoveEmptyEntries); + + switch (tokens[0]) + { + case "newmtl": + currentMaterial = new ObjMaterial(tokens[1]); + materials[currentMaterial.Name] = currentMaterial; + break; + + case "map_Kd": + string textureFilePath = Path.GetFullPath(Path.Combine(dirPath, tokens[1])); + + if (File.Exists(textureFilePath)) + currentMaterial.TextureFilePath = textureFilePath; + + break; + } + } + } + + private void ImportObjects() + { + var inputs = new List(); + IndexedInput positionInput, texCoordInput, normalInput; + + positionInput = new IndexedInput(Semantic.Position, new Source(points)); + inputs.Add(positionInput); + + if (texCoords.Count > 0) + { + texCoordInput = new IndexedInput(Semantic.TexCoord, new Source(texCoords)); + inputs.Add(texCoordInput); + } + else + { + texCoordInput = null; + } + + if (normals.Count > 0) + { + normalInput = new IndexedInput(Semantic.Normal, new Source(normals)); + inputs.Add(normalInput); + } + else + { + normalInput = null; + } + + var geometry = new Geometry + { + Vertices = { positionInput } + }; + + var geometryInstance = new GeometryInstance + { + Target = geometry + }; + + foreach (var primitive in primitives.Where(p => p.Faces.Count > 0)) + { + var meshPrimtives = new MeshPrimitives(MeshPrimitiveType.Polygons, inputs); + + foreach (var face in primitive.Faces) + { + meshPrimtives.VertexCounts.Add(face.Vertices.Length); + + foreach (var vertex in face.Vertices) + { + positionInput.Indices.Add(vertex.PointIndex); + + if (texCoordInput != null) + texCoordInput.Indices.Add(vertex.TexCoordIndex); + + if (normalInput != null) + normalInput.Indices.Add(vertex.NormalIndex); + } + } + + geometry.Primitives.Add(meshPrimtives); + + if (primitive.Material != null && primitive.Material.Material != null) + { + meshPrimtives.MaterialSymbol = "mat" + geometryInstance.Materials.Count; + + geometryInstance.Materials.Add(new MaterialInstance + { + Symbol = meshPrimtives.MaterialSymbol, + Target = primitive.Material.Material, + Bindings = { new MaterialBinding("diffuse_TEXCOORD", texCoordInput) } + }); + } + } + + mainScene.Nodes.Add(new Node + { + Instances = { geometryInstance } + }); + } + + private Vector3 ComputeFaceNormal(ObjVertex[] vertices) + { + if (vertices.Length < 3) + return Vector3.Up; + + var v1 = points[vertices[0].PointIndex]; + var v2 = points[vertices[1].PointIndex]; + var v3 = points[vertices[2].PointIndex]; + + return Vector3.Normalize(Vector3.Cross(v2 - v1, v3 - v1)); + } + + private static IEnumerable ReadLines(string filePath) + { + using (var reader = File.OpenText(filePath)) + { + for (var line = reader.ReadLine(); line != null; line = reader.ReadLine()) + { + line = line.Trim(); + + if (line.Length == 0) + continue; + + int commentStart = line.IndexOf('#'); + + if (commentStart != -1) + { + line = line.Substring(0, commentStart).Trim(); + + if (line.Length == 0) + continue; + } + + yield return line; + } + } + } + } +} Index: /OniSplit/Dae/IO/ObjWriter.cs =================================================================== --- /OniSplit/Dae/IO/ObjWriter.cs (revision 1114) +++ /OniSplit/Dae/IO/ObjWriter.cs (revision 1114) @@ -0,0 +1,260 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using Oni.Collections; + +namespace Oni.Dae.IO +{ + internal class ObjWriter + { + private int vBase = 1, vtBase = 1, vnBase = 1; + private Set materials = new Set(); + private StreamWriter objWriter; + private StreamWriter mtlWriter; + + internal static void WriteFile(string filePath, Scene scene) + { + var writer = new ObjWriter(); + writer.Write(filePath, scene); + } + + private void Write(string filePath, Scene scene) + { + using (objWriter = File.CreateText(filePath)) + { + objWriter.WriteLine("# Generated by OniSplit v{0}", Utils.Version); + objWriter.WriteLine(); + + objWriter.WriteLine("mtllib {0}", Path.ChangeExtension(Path.GetFileName(filePath), ".mtl")); + objWriter.WriteLine(); + + var rootTransform = Matrix.Identity; + + WriteNode(scene, ref rootTransform); + } + + using (mtlWriter = File.CreateText(Path.ChangeExtension(filePath, ".mtl"))) + { + mtlWriter.WriteLine("# Generated by OniSplit v{0}", Utils.Version); + mtlWriter.WriteLine(); + + WriteMaterialLibrary(); + } + } + + private void WriteNode(Node node, ref Matrix parentTransform) + { + if (!string.IsNullOrEmpty(node.Name)) + objWriter.WriteLine("g {0}", node.Name); + + var transform = node.Transforms.ToMatrix() * parentTransform; + + foreach (var geometryInstance in node.GeometryInstances) + WriteGeometry(geometryInstance, ref transform); + + foreach (var child in node.Nodes) + WriteNode(child, ref transform); + } + + private void WriteGeometry(GeometryInstance geometryInstance, ref Matrix transform) + { + var geometry = geometryInstance.Target; + + foreach (var primitives in geometry.Primitives) + { + var posInput = WritePositions(primitives, ref transform); + var texCoordInput = WriteTexCoords(primitives); + var normalInput = WriteNormals(primitives, ref transform); + + WriteUseMaterial(geometryInstance, primitives); + WriteFaces(primitives, posInput, texCoordInput, normalInput); + + vBase += posInput.Source.Count; + vtBase += texCoordInput == null ? 0 : texCoordInput.Source.Count; + vnBase += normalInput == null ? 0: normalInput.Source.Count; + } + } + + private IndexedInput WritePositions(MeshPrimitives primitives, ref Matrix transform) + { + var input = primitives.Inputs.FirstOrDefault(i => i.Semantic == Semantic.Position); + var source = input.Source; + + for (int i = 0; i < source.Count; i++) + { + var position = Vector3.Transform(Source.ReadVector3(source, i), ref transform); + + objWriter.Write("v "); + objWriter.Write(position.X.ToString(CultureInfo.InvariantCulture)); + objWriter.Write(' '); + objWriter.Write(position.Y.ToString(CultureInfo.InvariantCulture)); + objWriter.Write(' '); + objWriter.Write(position.Z.ToString(CultureInfo.InvariantCulture)); + objWriter.WriteLine(); + } + + objWriter.WriteLine(); + + return input; + } + + private IndexedInput WriteTexCoords(MeshPrimitives primitives) + { + var input = primitives.Inputs.FirstOrDefault(i => i.Semantic == Semantic.TexCoord); + + if (input == null) + return null; + + var source = input.Source; + var data = source.FloatData; + + for (int i = 0; i < data.Length; i += source.Stride) + { + objWriter.Write("vt "); + objWriter.Write(data[i + 0].ToString(CultureInfo.InvariantCulture)); + objWriter.Write(' '); + objWriter.Write(data[i + 1].ToString(CultureInfo.InvariantCulture)); + objWriter.WriteLine(); + } + + objWriter.WriteLine(); + + return input; + } + + private IndexedInput WriteNormals(MeshPrimitives primitives, ref Matrix transform) + { + var input = primitives.Inputs.FirstOrDefault(i => i.Semantic == Semantic.Normal); + + if (input == null) + return null; + + var source = input.Source; + + for (int i = 0; i < source.Count; i++) + { + var normal = Vector3.TransformNormal(Source.ReadVector3(source, i), ref transform); + + objWriter.Write("vn "); + objWriter.Write(normal.X.ToString(CultureInfo.InvariantCulture)); + objWriter.Write(' '); + objWriter.Write(normal.Y.ToString(CultureInfo.InvariantCulture)); + objWriter.Write(' '); + objWriter.Write(normal.Z.ToString(CultureInfo.InvariantCulture)); + objWriter.WriteLine(); + } + + objWriter.WriteLine(); + + return input; + } + + private void WriteFaces(MeshPrimitives primitives, IndexedInput posInput, IndexedInput texCoordInput, IndexedInput normalInput) + { + var positionIndices = posInput.Indices; + var texCoordIndices = texCoordInput == null ? null : texCoordInput.Indices; + var normalIndices = normalInput == null ? null : normalInput.Indices; + int vertexIndex = 0; + + foreach (var vertexCount in primitives.VertexCounts) + { + objWriter.Write("f"); + + for (int i = vertexIndex; i < vertexIndex + vertexCount; i++) + { + objWriter.Write(' '); + objWriter.Write((vBase + positionIndices[i]).ToString(CultureInfo.InvariantCulture)); + + if (texCoordIndices != null) + { + objWriter.Write('/'); + objWriter.Write((vtBase + texCoordIndices[i]).ToString(CultureInfo.InvariantCulture)); + } + else if (normalIndices != null) + { + objWriter.Write('/'); + } + + if (normalIndices != null) + { + objWriter.Write('/'); + objWriter.Write((vnBase + normalIndices[i]).ToString(CultureInfo.InvariantCulture)); + } + } + + objWriter.WriteLine(); + + vertexIndex += vertexCount; + } + + objWriter.WriteLine(); + } + + private void WriteUseMaterial(GeometryInstance geometryInstance, MeshPrimitives primitives) + { + if (string.IsNullOrEmpty(primitives.MaterialSymbol)) + { + objWriter.WriteLine("usemtl"); + } + else + { + var materialInstance = geometryInstance.Materials.Find(m => m.Symbol == primitives.MaterialSymbol); + + if (materialInstance != null && materialInstance.Target != null) + { + objWriter.WriteLine("usemtl {0}", materialInstance.Target.Name); + materials.Add(materialInstance.Target); + } + } + } + + private void WriteMaterialLibrary() + { + foreach (var material in materials) + { + mtlWriter.WriteLine("newmtl {0}", material.Name); + + var effect = material.Effect; + + WriteMaterialColor("Ka", effect.Ambient); + WriteMaterialColor("Kd", effect.Diffuse); + + mtlWriter.WriteLine("Ks 0 0 0"); + mtlWriter.WriteLine("Ns 0"); + + WriteMaterialTextureMap("map_Kd", effect.Diffuse); + WriteMaterialTextureMap("map_Tr", effect.Transparent); + + if (effect.TransparentValue is EffectTexture) + mtlWriter.WriteLine("illum 9"); + else + mtlWriter.WriteLine("illum 2"); + + mtlWriter.WriteLine(); + } + } + + private void WriteMaterialColor(string mtlCommand, EffectParameter effectParam) + { + if (effectParam == null || !(effectParam.Value is Vector4)) + return; + + var color = (Vector4)effectParam.Value; + mtlWriter.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} {1} {2} {3}", mtlCommand, color.X, color.Y, color.Z)); + } + + private void WriteMaterialTextureMap(string mtlCommand, EffectParameter effectParam) + { + if (effectParam == null) + return; + + var texture = effectParam.Value as EffectTexture; + + if (texture == null) + return; + + mtlWriter.WriteLine("{0} {1}", mtlCommand, texture.Sampler.Surface.InitFrom.FilePath); + } + } +} Index: /OniSplit/Dae/Image.cs =================================================================== --- /OniSplit/Dae/Image.cs (revision 1114) +++ /OniSplit/Dae/Image.cs (revision 1114) @@ -0,0 +1,16 @@ +namespace Oni.Dae +{ + internal class Image : Entity + { + public Image() + { + } + + public Image(string filePath) + { + FilePath = filePath; + } + + public string FilePath { get; set; } + } +} Index: /OniSplit/Dae/IndexedInput.cs =================================================================== --- /OniSplit/Dae/IndexedInput.cs (revision 1114) +++ /OniSplit/Dae/IndexedInput.cs (revision 1114) @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal class IndexedInput : Input + { + private readonly List indices = new List(); + + public IndexedInput() + { + } + + public IndexedInput(Semantic semantic, Source source) + : base(semantic, source) + { + } + + // Currently only used by readers/writers, probably not needed for the rest + internal int Offset { get; set; } + + public int Set { get; set; } + + public List Indices => indices; + } +} Index: /OniSplit/Dae/Input.cs =================================================================== --- /OniSplit/Dae/Input.cs (revision 1114) +++ /OniSplit/Dae/Input.cs (revision 1114) @@ -0,0 +1,26 @@ +using System; + +namespace Oni.Dae +{ + internal class Input + { + public Input() + { + } + + public Input(Semantic semantic, Source source) + { + if (semantic == Semantic.None) + throw new ArgumentException("Semantic None is not a valid value", "semantic"); + + if (source == null) + throw new ArgumentNullException("source"); + + Semantic = semantic; + Source = source; + } + + public Semantic Semantic { get; set; } + public Source Source { get; set; } + } +} Index: /OniSplit/Dae/Instance.cs =================================================================== --- /OniSplit/Dae/Instance.cs (revision 1114) +++ /OniSplit/Dae/Instance.cs (revision 1114) @@ -0,0 +1,24 @@ +namespace Oni.Dae +{ + internal abstract class Instance + { + public string Sid { get; set; } + public string Name { get; set; } + } + + internal abstract class Instance : Instance + { + private T target; + + public Instance() + { + } + + public Instance(T target) + { + Target = target; + } + + public T Target { get; set; } + } +} Index: /OniSplit/Dae/Light.cs =================================================================== --- /OniSplit/Dae/Light.cs (revision 1114) +++ /OniSplit/Dae/Light.cs (revision 1114) @@ -0,0 +1,14 @@ +namespace Oni.Dae +{ + internal class Light : Entity + { + public LightType Type { get; set; } + public Vector3 Color { get; set; } + public float ConstantAttenuation { get; set; } + public float LinearAttenuation { get; set; } + public float QuadraticAttenuation { get; set; } + public float FalloffAngle { get; set; } + public float FalloffExponent { get; set; } + public float ZFar { get; set; } + } +} Index: /OniSplit/Dae/LightInstance.cs =================================================================== --- /OniSplit/Dae/LightInstance.cs (revision 1114) +++ /OniSplit/Dae/LightInstance.cs (revision 1114) @@ -0,0 +1,14 @@ +namespace Oni.Dae +{ + internal class LightInstance : Instance + { + public LightInstance() + { + } + + public LightInstance(Light light) + : base(light) + { + } + } +} Index: /OniSplit/Dae/LightType.cs =================================================================== --- /OniSplit/Dae/LightType.cs (revision 1114) +++ /OniSplit/Dae/LightType.cs (revision 1114) @@ -0,0 +1,11 @@ +namespace Oni.Dae +{ + internal enum LightType + { + Invalid, + Ambient, + Directional, + Point, + Spot + } +} Index: /OniSplit/Dae/Material.cs =================================================================== --- /OniSplit/Dae/Material.cs (revision 1114) +++ /OniSplit/Dae/Material.cs (revision 1114) @@ -0,0 +1,7 @@ +namespace Oni.Dae +{ + internal class Material : Entity + { + public Effect Effect { get; set; } + } +} Index: /OniSplit/Dae/MaterialBinding.cs =================================================================== --- /OniSplit/Dae/MaterialBinding.cs (revision 1114) +++ /OniSplit/Dae/MaterialBinding.cs (revision 1114) @@ -0,0 +1,18 @@ +namespace Oni.Dae +{ + internal class MaterialBinding + { + public MaterialBinding() + { + } + + public MaterialBinding(string semantic, IndexedInput input) + { + Semantic = semantic; + VertexInput = input; + } + + public string Semantic { get; set; } + public IndexedInput VertexInput { get; set; } + } +} Index: /OniSplit/Dae/MaterialInstance.cs =================================================================== --- /OniSplit/Dae/MaterialInstance.cs (revision 1114) +++ /OniSplit/Dae/MaterialInstance.cs (revision 1114) @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal class MaterialInstance : Instance + { + private readonly List bindings = new List(); + + public MaterialInstance() + { + } + + public MaterialInstance(string symbol, Material material) + : base(material) + { + Symbol = symbol; + } + + public string Symbol { get; set; } + + public List Bindings => bindings; + } +} Index: /OniSplit/Dae/MeshPrimitiveType.cs =================================================================== --- /OniSplit/Dae/MeshPrimitiveType.cs (revision 1114) +++ /OniSplit/Dae/MeshPrimitiveType.cs (revision 1114) @@ -0,0 +1,11 @@ +namespace Oni.Dae +{ + internal enum MeshPrimitiveType + { + Lines, + LineStrips, + Polygons, + TriangleFans, + TriangleStrips, + } +} Index: /OniSplit/Dae/MeshPrimitives.cs =================================================================== --- /OniSplit/Dae/MeshPrimitives.cs (revision 1114) +++ /OniSplit/Dae/MeshPrimitives.cs (revision 1114) @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal class MeshPrimitives + { + private readonly MeshPrimitiveType primitiveType; + private readonly List inputs; + private readonly List vertexCounts; + + public MeshPrimitives(MeshPrimitiveType primitiveType) + { + this.primitiveType = primitiveType; + this.inputs = new List(3); + this.vertexCounts = new List(); + } + + public MeshPrimitives(MeshPrimitiveType primitiveType, IEnumerable inputs) + { + this.primitiveType = primitiveType; + this.inputs = new List(inputs); + this.vertexCounts = new List(); + } + + public MeshPrimitiveType PrimitiveType => primitiveType; + + public string MaterialSymbol { get; set; } + + public List Inputs => inputs; + + public List VertexCounts => vertexCounts; + } +} Index: /OniSplit/Dae/Node.cs =================================================================== --- /OniSplit/Dae/Node.cs (revision 1114) +++ /OniSplit/Dae/Node.cs (revision 1114) @@ -0,0 +1,56 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal class Node : Entity + { + private TransformCollection transforms; + private List instances; + private List nodes; + + public TransformCollection Transforms + { + get + { + if (transforms == null) + transforms = new TransformCollection(); + + return transforms; + } + } + + public List Instances + { + get + { + if (instances == null) + instances = new List(); + + return instances; + } + } + + public IEnumerable GeometryInstances + { + get + { + if (instances == null) + return new GeometryInstance[0]; + + return instances.OfType(); + } + } + + public List Nodes + { + get + { + if (nodes == null) + nodes = new List(); + + return nodes; + } + } + } +} Index: /OniSplit/Dae/NodeInstance.cs =================================================================== --- /OniSplit/Dae/NodeInstance.cs (revision 1114) +++ /OniSplit/Dae/NodeInstance.cs (revision 1114) @@ -0,0 +1,14 @@ +namespace Oni.Dae +{ + internal class NodeInstance : Instance + { + public NodeInstance() + { + } + + public NodeInstance(Node node) + : base(node) + { + } + } +} Index: /OniSplit/Dae/Reader.cs =================================================================== --- /OniSplit/Dae/Reader.cs (revision 1114) +++ /OniSplit/Dae/Reader.cs (revision 1114) @@ -0,0 +1,20 @@ +using System; +using System.IO; + +namespace Oni.Dae +{ + internal class Reader + { + public static Scene ReadFile(string filePath) + { + string type = Path.GetExtension(filePath); + + if (string.Equals(type, ".dae", StringComparison.OrdinalIgnoreCase)) + return IO.DaeReader.ReadFile(filePath); + else if (string.Equals(type, ".obj", StringComparison.OrdinalIgnoreCase)) + return IO.ObjReader.ReadFile(filePath); + else + throw new NotSupportedException($"Unsupported 3D file type {type}"); + } + } +} Index: /OniSplit/Dae/Sampler.cs =================================================================== --- /OniSplit/Dae/Sampler.cs (revision 1114) +++ /OniSplit/Dae/Sampler.cs (revision 1114) @@ -0,0 +1,266 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal class Sampler : Entity + { + private readonly List inputs = new List(); + private float outputScale = 1.0f; + + public List Inputs => inputs; + + public int FrameCount + { + get + { + var input = inputs.Find(i => i.Semantic == Semantic.Input); + + if (input == null) + return 0; + + return FMath.RoundToInt32(input.Source.FloatData.Last() * 60.0f) + 1; + } + } + + public Sampler Scale(float scale) + { + var newSampler = new Sampler + { + outputScale = scale + }; + + newSampler.inputs.AddRange(inputs); + + return newSampler; + } + + public Sampler Split(int offset) + { + var newSampler = new Sampler(); + + foreach (var input in inputs) + { + var source = input.Source; + + switch (input.Semantic) + { + case Semantic.Input: + newSampler.inputs.Add(input); + break; + + case Semantic.Interpolation: + newSampler.inputs.Add(input); + break; + + case Semantic.Output: + { + var data = new float[source.Count]; + + for (int i = 0; i < data.Length; i++) + data[i] = source.FloatData[i * source.Stride + offset]; + + newSampler.inputs.Add(new Input + { + Source = new Source(data, 1), + Semantic = input.Semantic + }); + } + break; + + case Semantic.InTangent: + case Semantic.OutTangent: + { + var data = new float[source.Count * 2]; + + for (int i = 0; i < data.Length; i++) + { + data[i + 0] = source.FloatData[i * source.Stride]; + data[i + 1] = source.FloatData[i * source.Stride + (offset + 1)]; + } + + newSampler.inputs.Add(new Input + { + Source = new Source(data, 2), + Semantic = input.Semantic + }); + } + break; + } + } + + return newSampler; + } + + public float[] Sample() => Sample(0, FrameCount - 1); + + public float[] Sample(int start, int end) + { + var result = Sample(start, end, 0); + + if (outputScale != 1.0f) + { + for (int i = 0; i < result.Length; i++) + result[i] *= outputScale; + } + + return result; + } + + private float[] Sample(int start, int end, int offset) + { + float[] input = null; + float[] output = null; + int outputStride = 1; + Vector2[] inTangent = null; + Vector2[] outTangent = null; + string[] interpolation = null; + + foreach (var i in inputs) + { + switch (i.Semantic) + { + case Semantic.Input: + input = i.Source.FloatData; + break; + + case Semantic.Output: + output = i.Source.FloatData; + outputStride = i.Source.Stride; + break; + + case Semantic.InTangent: + inTangent = FloatArrayToVector2Array(i.Source.FloatData); + break; + + case Semantic.OutTangent: + outTangent = FloatArrayToVector2Array(i.Source.FloatData); + break; + + case Semantic.Interpolation: + interpolation = i.Source.NameData; + break; + } + } + + if (offset >= outputStride) + throw new ArgumentException("The offset must be less than the output stride", "offset"); + + float[] result = new float[end - start + 1]; + + if (input == null || output == null || interpolation == null) + { + // + // If we don't have enough data to sample then we just return 0 for all frames. + // + + return result; + } + + if (output.Length == outputStride) + { + // + // If the output contains only one element then use that for all frames. + // + + for (int i = 0; i < result.Length; i++) + result[i] = output[offset]; + + return result; + } + + float inputFirst = input.First(); + float outputFirst = output[offset]; + + float inputLast = input.Last(); + float outputLast = output[output.Length - outputStride + offset]; + + for (int frame = 0; frame < result.Length; frame++) + { + float t = (frame + start) / 60.0f; + + if (t <= inputFirst) + { + result[frame] = outputFirst; + continue; + } + + if (t >= inputLast) + { + result[frame] = outputLast; + continue; + } + + int index = Array.BinarySearch(input, t); + + if (index >= 0) + { + result[frame] = output[index * outputStride + offset]; + continue; + } + + index = ~index; + + if (index == 0) + { + result[frame] = outputFirst; + continue; + } + + if (index * outputStride + offset >= output.Length) + { + result[frame] = outputLast; + continue; + } + + var p0 = new Vector2(input[index - 1], output[(index - 1) * outputStride + offset]); + var p1 = new Vector2(input[index], output[index * outputStride + offset]); + + float s = (t - p0.X) / (p1.X - p0.X); + + switch (interpolation[index - 1]) + { + default: + Console.Error.WriteLine("Interpolation type '{0}' is not supported, using LINEAR", interpolation[index - 1]); + goto case "LINEAR"; + + case "LINEAR": + result[frame] = p0.Y + s * (p1.Y - p0.Y); + break; + + case "BEZIER": + if (inTangent == null || outTangent == null) + throw new System.IO.InvalidDataException("Bezier interpolation was specified but in/out tangents are not present"); + + var c0 = outTangent[index - 1]; + var c1 = inTangent[index]; + + float invS = 1.0f - s; + + result[frame] = + p0.Y * invS * invS * invS + + 3.0f * c0.Y * invS * invS * s + + 3.0f * c1.Y * invS * s * s + + p1.Y * s * s * s; + + break; + } + } + + return result; + } + + private static Vector2[] FloatArrayToVector2Array(float[] array) + { + var result = new Vector2[array.Length / 2]; + + for (int i = 0; i < result.Length; i++) + { + result[i].X = array[i * 2 + 0]; + result[i].Y = array[i * 2 + 1]; + } + + return result; + } + } +} Index: /OniSplit/Dae/Scene.cs =================================================================== --- /OniSplit/Dae/Scene.cs (revision 1114) +++ /OniSplit/Dae/Scene.cs (revision 1114) @@ -0,0 +1,6 @@ +namespace Oni.Dae +{ + internal class Scene : Node + { + } +} Index: /OniSplit/Dae/Semantic.cs =================================================================== --- /OniSplit/Dae/Semantic.cs (revision 1114) +++ /OniSplit/Dae/Semantic.cs (revision 1114) @@ -0,0 +1,19 @@ +namespace Oni.Dae +{ + internal enum Semantic + { + None, + + Position, + Normal, + TexCoord, + Color, + Vertex, + + Input, + InTangent, + OutTangent, + Interpolation, + Output, + } +} Index: /OniSplit/Dae/Source.cs =================================================================== --- /OniSplit/Dae/Source.cs (revision 1114) +++ /OniSplit/Dae/Source.cs (revision 1114) @@ -0,0 +1,125 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal class Source : Entity + { + private float[] floatData; + private string[] nameData; + private int stride; + private int count; + + public Source(IEnumerable data, int stride) + { + this.floatData = data.ToArray(); + this.stride = stride; + this.count = floatData.Length / stride; + } + + public Source(float[] data, int stride) + { + this.floatData = (float[])data.Clone(); + this.stride = stride; + this.count = data.Length / stride; + } + + public Source(string[] data, int stride) + { + this.nameData = (string[])data.Clone(); + this.stride = stride; + this.count = data.Length / stride; + } + + public Source(IList data) + { + int count = data.Count; + float[] array = new float[count * 2]; + + for (int i = 0; i < count; i++) + { + array[i * 2 + 0] = data[i].X; + array[i * 2 + 1] = 1.0f - data[i].Y; + } + + this.floatData = array; + this.count = count; + this.stride = 2; + } + + public Source(IList data) + { + int count = data.Count; + float[] array = new float[count * 3]; + + for (int i = 0; i < count; i++) + { + array[i * 3 + 0] = data[i].X; + array[i * 3 + 1] = data[i].Y; + array[i * 3 + 2] = data[i].Z; + } + + this.floatData = array; + this.count = count; + this.stride = 3; + } + + public string[] NameData => nameData; + public float[] FloatData => floatData; + public int Count => count; + + public int Stride + { + get + { + return stride; + } + set + { + stride = value; + + if (floatData != null) + count = floatData.Length / stride; + else + count = nameData.Length / stride; + } + } + + public static Vector2 ReaderVector2(Source source, int index) + { + var data = source.floatData; + var i = index * source.stride; + + return new Vector2(data[i + 0], data[i + 1]); + } + + public static Vector2 ReadTexCoord(Source source, int index) + { + var data = source.floatData; + var i = index * source.stride; + + return new Vector2(data[i + 0], 1.0f - data[i + 1]); + } + + public static Vector3 ReadVector3(Source source, int index) + { + var data = source.floatData; + var i = index * source.stride; + + return new Vector3(data[i + 0], data[i + 1], data[i + 2]); + } + + public static Vector4 ReadVector4(Source source, int index) + { + var data = source.floatData; + var i = index * source.stride; + + return new Vector4(data[i + 0], data[i + 1], data[i + 2], data[i + 3]); + } + + public static Imaging.Color ReadColor(Source source, int index) + { + return new Imaging.Color(ReadVector4(source, index)); + } + } +} Index: /OniSplit/Dae/Transform.cs =================================================================== --- /OniSplit/Dae/Transform.cs (revision 1114) +++ /OniSplit/Dae/Transform.cs (revision 1114) @@ -0,0 +1,98 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal abstract class Transform + { + private string sid; + private readonly float[] values; + private Sampler[] animations; + + protected Transform(int valueCount) + { + this.values = new float[valueCount]; + } + + protected Transform(string sid, int valueCount) + { + this.sid = sid; + this.values = new float[valueCount]; + } + + public string Sid + { + get { return sid; } + set { sid = value; } + } + + public float[] Values => values; + public bool HasAnimations => animations != null; + + public Sampler[] Animations + { + get + { + if (animations == null) + animations = new Sampler[values.Length]; + + return animations; + } + } + + protected Sampler GetAnimation(int index) + { + if (animations == null) + return null; + + return animations[index]; + } + + public void BindAnimation(string valueName, Sampler animation) + { + if (string.IsNullOrEmpty(valueName)) + { + for (int i = 0; i < values.Length; i++) + BindAnimation(i, animation); + } + else + { + int valueIndex = ParseValueIndex(valueName); + + if (valueIndex != -1) + BindAnimation(valueIndex, animation); + } + } + + private void BindAnimation(int index, Sampler animation) + { + if (animation.Inputs.Count == 0 || animation.Inputs[0].Source.Count == 0) + animation = null; + + if (animation == null && !HasAnimations) + return; + + Animations[index] = animation; + } + + private int ParseValueIndex(string name) + { + if (name[0] == '(') + { + int end = name.IndexOf(')', 1); + + if (end == -1) + return -1; + + return int.Parse(name.Substring(1, end - 1).Trim()); + } + + return ValueNameToValueIndex(name); + } + + public abstract int ValueNameToValueIndex(string name); + public abstract string ValueIndexToValueName(int index); + + public abstract Matrix ToMatrix(); + } +} Index: /OniSplit/Dae/TransformCollection.cs =================================================================== --- /OniSplit/Dae/TransformCollection.cs (revision 1114) +++ /OniSplit/Dae/TransformCollection.cs (revision 1114) @@ -0,0 +1,38 @@ +using System.Collections.Generic; + +namespace Oni.Dae +{ + internal class TransformCollection : List + { + public Matrix ToMatrix() + { + var matrix = Matrix.Identity; + + foreach (var transform in Utils.Reverse(this)) + matrix *= transform.ToMatrix(); + + return matrix; + } + + public TransformScale Scale(string sid, Vector3 scale) + { + var transform = new TransformScale(sid, scale); + Add(transform); + return transform; + } + + public TransformRotate Rotate(string sid, Vector3 axis, float angle) + { + var transform = new TransformRotate(sid, axis, angle); + Add(transform); + return transform; + } + + public TransformTranslate Translate(string sid, Vector3 translate) + { + var transform = new TransformTranslate(sid, translate); + Add(transform); + return transform; + } + } +} Index: /OniSplit/Dae/TransformMatrix.cs =================================================================== --- /OniSplit/Dae/TransformMatrix.cs (revision 1114) +++ /OniSplit/Dae/TransformMatrix.cs (revision 1114) @@ -0,0 +1,26 @@ +using System; + +namespace Oni.Dae +{ + internal class TransformMatrix : Transform + { + public TransformMatrix() + : base(16) + { + } + + public Matrix Matrix + { + get { return new Matrix(Values); } + set { value.CopyTo(Values); } + } + + public override Matrix ToMatrix() => Matrix; + public override int ValueNameToValueIndex(string name) => -1; + + public override string ValueIndexToValueName(int index) + { + throw new NotImplementedException(); + } + } +} Index: /OniSplit/Dae/TransformRotate.cs =================================================================== --- /OniSplit/Dae/TransformRotate.cs (revision 1114) +++ /OniSplit/Dae/TransformRotate.cs (revision 1114) @@ -0,0 +1,48 @@ +using System; + +namespace Oni.Dae +{ + internal class TransformRotate : Transform + { + private static readonly string[] valueNames = new[] { "X", "Y", "Z", "ANGLE" }; + + public TransformRotate() + : base(4) + { + } + + public TransformRotate(Vector3 axis, float angle) + : base(4) + { + Axis = axis; + Angle = angle; + } + + public TransformRotate(string sid, Vector3 axis, float angle) + : base(sid, 4) + { + Axis = axis; + Angle = angle; + } + + public Vector3 Axis + { + get { return new Vector3(Values); } + set { value.CopyTo(Values); } + } + + public float Angle + { + get { return Values[3]; } + set { Values[3] = value; } + } + + public Sampler AngleAnimation => GetAnimation(3); + + public override Matrix ToMatrix() => Matrix.CreateFromAxisAngle(Axis, MathHelper.ToRadians(Angle)); + public Quaternion ToQuaternion() => Quaternion.CreateFromAxisAngle(Axis, MathHelper.ToRadians(Angle)); + + public override int ValueNameToValueIndex(string name) => Array.FindIndex(valueNames, x => string.Equals(x, name, StringComparison.OrdinalIgnoreCase)); + public override string ValueIndexToValueName(int index) => valueNames[index]; + } +} Index: /OniSplit/Dae/TransformScale.cs =================================================================== --- /OniSplit/Dae/TransformScale.cs (revision 1114) +++ /OniSplit/Dae/TransformScale.cs (revision 1114) @@ -0,0 +1,31 @@ +using System; + +namespace Oni.Dae +{ + internal class TransformScale : Transform + { + private static readonly string[] valueNames = new[] { "X", "Y", "Z" }; + + public TransformScale() + : base(3) + { + } + + public TransformScale(string sid, Vector3 scale) + : base(sid, 3) + { + Scale = scale; + } + + public Vector3 Scale + { + get { return new Vector3(Values); } + set { value.CopyTo(Values); } + } + + public override Matrix ToMatrix() => Matrix.CreateScale(Scale); + + public override int ValueNameToValueIndex(string name) => Array.FindIndex(valueNames, x => string.Equals(x, name, StringComparison.OrdinalIgnoreCase)); + public override string ValueIndexToValueName(int index) => valueNames[index]; + } +} Index: /OniSplit/Dae/TransformTranslate.cs =================================================================== --- /OniSplit/Dae/TransformTranslate.cs (revision 1114) +++ /OniSplit/Dae/TransformTranslate.cs (revision 1114) @@ -0,0 +1,37 @@ +using System; + +namespace Oni.Dae +{ + internal class TransformTranslate : Transform + { + private static readonly string[] valueNames = new[] { "X", "Y", "Z" }; + + public TransformTranslate() + : base(3) + { + } + + public TransformTranslate(Vector3 translation) + : base(3) + { + Translation = translation; + } + + public TransformTranslate(string sid, Vector3 translation) + : base(sid, 3) + { + Translation = translation; + } + + public Vector3 Translation + { + get { return new Vector3(Values); } + set { value.CopyTo(Values); } + } + + public override Matrix ToMatrix() => Matrix.CreateTranslation(Translation); + + public override int ValueNameToValueIndex(string name) => Array.FindIndex(valueNames, x => string.Equals(x, name, StringComparison.OrdinalIgnoreCase)); + public override string ValueIndexToValueName(int index) => valueNames[index]; + } +} Index: /OniSplit/Dae/Visitor.cs =================================================================== --- /OniSplit/Dae/Visitor.cs (revision 1114) +++ /OniSplit/Dae/Visitor.cs (revision 1114) @@ -0,0 +1,146 @@ +namespace Oni.Dae +{ + internal class Visitor + { + public virtual void VisitScene(Scene scene) + { + foreach (var node in scene.Nodes) + VisitNode(node); + } + + public virtual void VisitNode(Node node) + { + foreach (var transform in node.Transforms) + VisitTransform(transform); + + foreach (var instance in node.Instances) + { + if (instance is GeometryInstance) + VisitGeometryInstance((GeometryInstance)instance); + else if (instance is LightInstance) + VisitLightInstance((LightInstance)instance); + else if (instance is CameraInstance) + VisitCameraInstance((CameraInstance)instance); + } + + foreach (var child in node.Nodes) + VisitNode(child); + } + + public virtual void VisitGeometryInstance(GeometryInstance instance) + { + foreach (var materialInstance in instance.Materials) + VisitMaterialInstance(materialInstance); + + VisitGeometry(instance.Target); + } + + public virtual void VisitGeometry(Geometry geometry) + { + foreach (var input in geometry.Vertices) + VisitInput(input); + + foreach (var primitives in geometry.Primitives) + VisitMeshPrimitives(primitives); + } + + public virtual void VisitMeshPrimitives(MeshPrimitives primitives) + { + foreach (var input in primitives.Inputs) + VisitInput(input); + } + + public virtual void VisitMaterialInstance(MaterialInstance instance) + { + VisitMaterial(instance.Target); + } + + public virtual void VisitMaterial(Material material) + { + VisitEffect(material.Effect); + } + + public virtual void VisitLightInstance(LightInstance instance) + { + VisitLight(instance.Target); + } + + public virtual void VisitLight(Light light) + { + } + + public virtual void VisitCameraInstance(CameraInstance instance) + { + VisitCamera(instance.Target); + } + + public virtual void VisitCamera(Camera camera) + { + } + + public virtual void VisitTransform(Transform transform) + { + if (transform.HasAnimations) + { + foreach (var sampler in transform.Animations.Where(s => s != null)) + VisitSampler(sampler); + } + } + + public virtual void VisitSampler(Sampler sampler) + { + foreach (var input in sampler.Inputs) + VisitInput(input); + } + + public virtual void VisitEffect(Effect effect) + { + foreach (var parameter in effect.Parameters) + VisitEffectParameter(parameter); + + VisitEffectParameter(effect.Ambient); + VisitEffectParameter(effect.Diffuse); + VisitEffectParameter(effect.Emission); + VisitEffectParameter(effect.IndexOfRefraction); + VisitEffectParameter(effect.Reflective); + VisitEffectParameter(effect.Shininess); + VisitEffectParameter(effect.Specular); + VisitEffectParameter(effect.Transparency); + VisitEffectParameter(effect.Transparent); + } + + public virtual void VisitEffectParameter(EffectParameter parameter) + { + if (parameter.Value is EffectTexture) + VisitEffectTexture((EffectTexture)parameter.Value); + } + + public virtual void VisitEffectTexture(EffectTexture texture) + { + VisitEffectSampler(texture.Sampler); + } + + public virtual void VisitEffectSampler(EffectSampler sampler) + { + VisitEffectSurface(sampler.Surface); + } + + public virtual void VisitEffectSurface(EffectSurface surface) + { + VisitImage(surface.InitFrom); + } + + public virtual void VisitInput(Input input) + { + VisitSource(input.Source); + } + + public virtual void VisitSource(Source source) + { + } + + public virtual void VisitImage(Image image) + { + } + } +} Index: /OniSplit/Dae/Writer.cs =================================================================== --- /OniSplit/Dae/Writer.cs (revision 1114) +++ /OniSplit/Dae/Writer.cs (revision 1114) @@ -0,0 +1,20 @@ +using System; +using System.IO; + +namespace Oni.Dae +{ + internal class Writer + { + public static void WriteFile(string filePath, Scene scene) + { + string type = Path.GetExtension(filePath); + + if (string.Equals(type, ".dae", StringComparison.OrdinalIgnoreCase)) + IO.DaeWriter.WriteFile(filePath, scene); + else if (string.Equals(type, ".obj", StringComparison.OrdinalIgnoreCase)) + IO.ObjWriter.WriteFile(filePath, scene); + else + throw new NotSupportedException(string.Format("Unsupported 3D file type {0}", type)); + } + } +} Index: /OniSplit/DaeExporter.cs =================================================================== --- /OniSplit/DaeExporter.cs (revision 1114) +++ /OniSplit/DaeExporter.cs (revision 1114) @@ -0,0 +1,296 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Oni +{ + internal class DaeExporter : Exporter + { + private readonly bool noAnimation; + private readonly List animationNames = new List(); + private readonly string geometryName; + private readonly string fileType; + + public DaeExporter(string[] args, InstanceFileManager fileManager, string outputDirPath, string fileType) + : base(fileManager, outputDirPath) + { + foreach (string arg in args) + { + if (arg == "-noanim") + noAnimation = true; + else if (arg.StartsWith("-anim:", StringComparison.Ordinal)) + animationNames.Add(arg.Substring(6)); + else if (arg.StartsWith("-geom:", StringComparison.Ordinal)) + geometryName = arg.Substring(6); + } + + this.fileType = fileType; + } + + protected override void ExportFile(string sourceFilePath) + { + string extension = Path.GetExtension(sourceFilePath); + + if (string.Equals(extension, ".xml", StringComparison.OrdinalIgnoreCase)) + { + var sceneExporter = new SceneExporter(InstanceFileManager, OutputDirPath); + sceneExporter.ExportScene(sourceFilePath); + return; + } + + base.ExportFile(sourceFilePath); + } + + protected override List GetSupportedDescriptors(InstanceFile file) + { + var descriptors = new List(); + descriptors.AddRange(file.GetNamedDescriptors(TemplateTag.ONCC)); + descriptors.AddRange(file.GetNamedDescriptors(TemplateTag.TRBS)); + descriptors.AddRange(file.GetNamedDescriptors(TemplateTag.M3GM)); + descriptors.AddRange(file.GetNamedDescriptors(TemplateTag.AKEV)); + descriptors.AddRange(file.GetNamedDescriptors(TemplateTag.OBAN)); + descriptors.AddRange(file.GetNamedDescriptors(TemplateTag.OFGA)); + descriptors.AddRange(file.GetNamedDescriptors(TemplateTag.ONWC)); + return descriptors; + } + + protected override void ExportInstance(InstanceDescriptor descriptor) + { + var tag = descriptor.Template.Tag; + + if (tag == TemplateTag.AKEV) + { + var mesh = Akira.AkiraDatReader.Read(descriptor); + Akira.AkiraDaeWriter.Write(mesh, descriptor.Name, OutputDirPath, fileType); + return; + } + + var scene = new Dae.Scene(); + scene.Name = descriptor.Name; + + var textureWriter = new Motoko.TextureDaeWriter(OutputDirPath); + var geometryWriter = new Motoko.GeometryDaeWriter(textureWriter); + var bodyWriter = new Totoro.BodyDaeWriter(geometryWriter); + + if (tag == TemplateTag.OFGA) + ExportObjectGeometry(descriptor, scene, geometryWriter); + else if (tag == TemplateTag.OBAN) + ExportObjectAnimation(descriptor, scene, geometryWriter); + else if (tag == TemplateTag.ONCC) + ExportCharacterBody(descriptor, scene, bodyWriter); + else if (tag == TemplateTag.TRBS) + ExportCharacterBodySet(descriptor, scene, bodyWriter); + else if (tag == TemplateTag.M3GM) + ExportGeometry(descriptor, scene, geometryWriter); + else if (tag == TemplateTag.ONWC) + ExportWeaponGeometry(descriptor, scene, geometryWriter); + + if (scene.Nodes.Count > 0) + { + string filePath = Path.Combine(OutputDirPath, descriptor.Name + "." + fileType); + + Dae.Writer.WriteFile(filePath, scene); + } + } + + private void ExportObjectGeometry(InstanceDescriptor descriptor, Dae.Scene scene, Motoko.GeometryDaeWriter geometryWriter) + { + var geometry = Physics.ObjectDatReader.ReadObjectGeometry(descriptor); + var root = new Dae.Node(); + + foreach (var objNode in geometry.Geometries) + root.Nodes.Add(geometryWriter.WriteNode(objNode.Geometry, objNode.Geometry.Name)); + + scene.Nodes.Add(root); + } + + private void ExportObjectAnimation(InstanceDescriptor descriptor, Dae.Scene scene, Motoko.GeometryDaeWriter geometryWriter) + { + var animation = Physics.ObjectDatReader.ReadAnimation(descriptor); + Dae.Node node; + + if (geometryName == "camera") + { + node = new Dae.Node + { + Name = descriptor.Name + "_camera", + Instances = { + new Dae.CameraInstance { + Target = new Dae.Camera { + XFov = 45.0f, + AspectRatio = 4.0f / 3.0f, + ZNear = 1.0f, + ZFar = 10000.0f + } + }} + }; + } + else if (geometryName != null) + { + var file = InstanceFileManager.OpenFile(geometryName); + + if (file == null) + { + Console.Error.WriteLine("Cannot fine file {0}", geometryName); + node = new Dae.Node(); + } + else + { + var geom = Motoko.GeometryDatReader.Read(file.Descriptors[0]); + node = geometryWriter.WriteNode(geom, geom.Name); + } + } + else + { + node = new Dae.Node(); + } + + scene.Nodes.Add(node); + + ExportAnimation(node, new List(animation.Keys)); + } + + private void ExportGeometry(InstanceDescriptor descriptor, Dae.Scene scene, Motoko.GeometryDaeWriter geometryWriter) + { + var animations = new List(animationNames.Count); + + foreach (string animationFilePath in animationNames) + { + var file = InstanceFileManager.OpenFile(animationFilePath); + + if (file == null) + { + Console.Error.WriteLine("Cannot find animation {0}", animationFilePath); + continue; + } + + animations.Add(Physics.ObjectDatReader.ReadAnimation(file.Descriptors[0])); + } + + ExportGeometry(scene, geometryWriter, descriptor, animations); + } + + private void ExportCharacterBodySet(InstanceDescriptor descriptor, Dae.Scene scene, Totoro.BodyDaeWriter bodyWriter) + { + var body = Totoro.BodyDatReader.Read(descriptor); + var node = bodyWriter.Write(body, noAnimation, null); + + scene.Nodes.Add(node); + } + + private void ExportCharacterBody(InstanceDescriptor descriptor, Dae.Scene scene, Totoro.BodyDaeWriter bodyWriter) + { + var animationName = animationNames.Count > 0 ? animationNames[0] : null; + var characterClass = Game.CharacterClass.Read(descriptor, animationName); + + var body = Totoro.BodyDatReader.Read(characterClass.Body); + var textures = characterClass.Textures; + var pelvis = bodyWriter.Write(body, noAnimation, textures); + + scene.Nodes.Add(pelvis); + + var animation = noAnimation ? null : characterClass.Animation; + + if (animation != null) + { + var anim = Totoro.AnimationDatReader.Read(animation); + + Totoro.AnimationDaeWriter.Write(pelvis, anim); + } + } + + private void ExportWeaponGeometry(InstanceDescriptor descriptor, Dae.Scene scene, Motoko.GeometryDaeWriter geometryWriter) + { + var weaponClass = Game.WeaponClass.Read(descriptor); + + if (weaponClass.Geometry != null) + ExportGeometry(weaponClass.Geometry, scene, geometryWriter); + } + + private static void ExportGeometry(Dae.Scene scene, Motoko.GeometryDaeWriter geometryWriter, InstanceDescriptor m3gm, List animations) + { + var geometry = Motoko.GeometryDatReader.Read(m3gm); + + if (animations != null && animations.Count > 0) + { + geometry.HasTransform = true; + geometry.Transform = Matrix.CreateScale(animations[0].Keys[0].Scale); + } + + var node = geometryWriter.WriteNode(geometry, m3gm.Name); + scene.Nodes.Add(node); + + if (animations != null && animations.Count > 0) + { + var frames = new List(); + int offset = 0; + + foreach (var animation in animations) + { + foreach (var key in animation.Keys) + { + frames.Add(new Physics.ObjectAnimationKey + { + Translation = key.Translation, + Rotation = key.Rotation, + Time = key.Time + offset + }); + } + + offset += animation.Length; + } + + ExportAnimation(node, frames); + } + } + + private static void ExportAnimation(Dae.Node node, List frames) + { + var times = new float[frames.Count]; + var interpolations = new string[times.Length]; + var positions = new Vector3[frames.Count]; + var angles = new Vector3[frames.Count]; + + for (int i = 0; i < times.Length; ++i) + times[i] = frames[i].Time / 60.0f; + + for (int i = 0; i < interpolations.Length; i++) + interpolations[i] = "LINEAR"; + + for (int i = 0; i < frames.Count; i++) + positions[i] = frames[i].Translation; + + for (int i = 0; i < frames.Count; i++) + angles[i] = frames[i].Rotation.ToEulerXYZ(); + + var translate = node.Transforms.Translate("translate", positions[0]); + var rotateX = node.Transforms.Rotate("rotX", Vector3.UnitX, angles[0].X); + var rotateY = node.Transforms.Rotate("rotY", Vector3.UnitY, angles[0].Y); + var rotateZ = node.Transforms.Rotate("rotZ", Vector3.UnitZ, angles[0].Z); + + WriteSampler(times, interpolations, i => positions[i].X, translate, "X"); + WriteSampler(times, interpolations, i => positions[i].Y, translate, "Y"); + WriteSampler(times, interpolations, i => positions[i].Z, translate, "Z"); + WriteSampler(times, interpolations, i => angles[i].X, rotateX, "ANGLE"); + WriteSampler(times, interpolations, i => angles[i].Y, rotateY, "ANGLE"); + WriteSampler(times, interpolations, i => angles[i].Z, rotateZ, "ANGLE"); + } + + private static void WriteSampler(float[] times, string[] interpolations, Func getValue, Dae.Transform transform, string targetName) + { + var values = new float[times.Length]; + + for (int i = 0; i < values.Length; ++i) + values[i] = getValue(i); + + transform.BindAnimation(targetName, new Dae.Sampler + { + Inputs = { + new Dae.Input(Dae.Semantic.Input, new Dae.Source(times, 1)), + new Dae.Input(Dae.Semantic.Output, new Dae.Source(values, 1)), + new Dae.Input(Dae.Semantic.Interpolation, new Dae.Source(interpolations, 1)) + } + }); + } + } +} Index: /OniSplit/DatPacker.cs =================================================================== --- /OniSplit/DatPacker.cs (revision 1114) +++ /OniSplit/DatPacker.cs (revision 1114) @@ -0,0 +1,127 @@ +using System; +using System.Collections.Generic; +using Oni.Collections; + +namespace Oni +{ + internal sealed class DatPacker + { + private readonly List inputPaths = new List(); + private string targetFilePath; + private bool targetBigEndian; + private long targetTemplateChecksum; + + public List InputPaths => inputPaths; + + public string TargetFilePath + { + get { return targetFilePath; } + set { targetFilePath = value; } + } + + public bool TargetBigEndian + { + get { return targetBigEndian; } + set { targetBigEndian = value; } + } + + public long TargetTemplateChecksum + { + get { return targetTemplateChecksum; } + set { targetTemplateChecksum = value; } + } + + public void Pack(InstanceFileManager fileManager, IEnumerable filePaths) + { + var inputs = new List(); + var seenFilePaths = new Set(StringComparer.OrdinalIgnoreCase); + + foreach (string filePath in filePaths) + { + if (seenFilePaths.Add(filePath)) + inputs.Add(fileManager.OpenFile(filePath)); + } + + inputs.Reverse(); + + var descriptors = GetImportedDescriptors(inputs); + + if (descriptors.Count > 0) + { + var writer = InstanceFileWriter.CreateV31(targetTemplateChecksum, targetBigEndian); + writer.AddDescriptors(descriptors, true); + + Console.WriteLine("Writing {0}", targetFilePath); + + writer.Write(targetFilePath); + } + } + + public void Import(InstanceFileManager fileManager, string[] inputDirPaths) + { + Console.WriteLine("Reading files from {0}", string.Join(";", inputDirPaths)); + + var inputsFiles = fileManager.OpenDirectories(inputDirPaths); + var descriptors = GetImportedDescriptors(inputsFiles); + + if (descriptors.Count > 0) + { + var writer = InstanceFileWriter.CreateV31(targetTemplateChecksum, targetBigEndian); + writer.AddDescriptors(descriptors, true); + + Console.WriteLine("Writing {0}", targetFilePath); + + writer.Write(targetFilePath); + } + } + + private static List GetImportedDescriptors(List inputFiles) + { + var namedDescriptors = new Set(StringComparer.Ordinal); + var ignored = new Set(); + + foreach (var file in inputFiles) + { + foreach (var descriptor in file.GetNamedDescriptors()) + { + if (namedDescriptors.Contains(descriptor.FullName)) + { + //Console.Error.WriteLine("WARNING: More than one instance has name {0}, ignoring.", descriptor.FullName); + ignored.Add(descriptor); + } + else + { + namedDescriptors.Add(descriptor.FullName); + } + } + } + + inputFiles.Sort((x, y) => string.Compare(x.Descriptors[0].FullName, y.Descriptors[0].FullName, StringComparison.Ordinal)); + + var descriptors = new List(4096); + + foreach (var file in inputFiles) + { + foreach (var descriptor in file.Descriptors) + { + if (ignored.Contains(descriptor)) + continue; + + if (descriptor.HasName) + { + if (descriptor.IsPlaceholder && namedDescriptors.Contains(descriptor.FullName)) + continue; + + namedDescriptors.Add(descriptor.FullName); + } + + descriptors.Add(descriptor); + } + } + + descriptors.Sort((x, y) => x.Template.IsLeaf.CompareTo(y.Template.IsLeaf)); + + return descriptors; + } + } +} Index: /OniSplit/DatUnpacker.cs =================================================================== --- /OniSplit/DatUnpacker.cs (revision 1114) +++ /OniSplit/DatUnpacker.cs (revision 1114) @@ -0,0 +1,17 @@ +namespace Oni +{ + internal sealed class DatUnpacker : Exporter + { + public DatUnpacker(InstanceFileManager fileManager, string outputDirPath) + : base(fileManager, outputDirPath) + { + } + + protected override void ExportInstance(InstanceDescriptor descriptor) + { + var referencedDescriptors = descriptor.GetReferencedDescriptors(); + var writer = InstanceFileWriter.CreateV32(referencedDescriptors); + writer.Write(CreateFileName(descriptor, ".oni")); + } + } +} Index: /OniSplit/DatWriter.cs =================================================================== --- /OniSplit/DatWriter.cs (revision 1114) +++ /OniSplit/DatWriter.cs (revision 1114) @@ -0,0 +1,10 @@ +namespace Oni +{ + internal sealed class DatWriter : Importer + { + public DatWriter() + { + BeginImport(); + } + } +} Index: /OniSplit/Exporter.cs =================================================================== --- /OniSplit/Exporter.cs (revision 1114) +++ /OniSplit/Exporter.cs (revision 1114) @@ -0,0 +1,73 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text.RegularExpressions; + +namespace Oni +{ + internal abstract class Exporter + { + private readonly InstanceFileManager fileManager; + private readonly string outputDirPath; + private readonly Dictionary fileNames; + private Regex nameFilter; + + protected Exporter(InstanceFileManager fileManager, string outputDirPath) + { + this.fileManager = fileManager; + this.outputDirPath = outputDirPath; + this.fileNames = new Dictionary(StringComparer.OrdinalIgnoreCase); + } + + public InstanceFileManager InstanceFileManager => fileManager; + + public string OutputDirPath => outputDirPath; + + public Regex NameFilter + { + get { return nameFilter; } + set { nameFilter = value; } + } + + public void ExportFiles(IEnumerable sourceFilePaths) + { + Directory.CreateDirectory(outputDirPath); + + foreach (var sourceFilePath in sourceFilePaths) + ExportFile(sourceFilePath); + + Flush(); + } + + protected virtual void ExportFile(string sourceFilePath) + { + Console.WriteLine(sourceFilePath); + + var file = fileManager.OpenFile(sourceFilePath); + var descriptors = GetSupportedDescriptors(file); + + if (nameFilter != null) + descriptors = descriptors.FindAll(x => x.HasName && nameFilter.IsMatch(x.FullName)); + + foreach (var descriptor in descriptors) + ExportInstance(descriptor); + } + + protected abstract void ExportInstance(InstanceDescriptor descriptor); + + protected virtual void Flush() + { + } + + protected virtual List GetSupportedDescriptors(InstanceFile file) + { + return file.GetNamedDescriptors(); + } + + protected string CreateFileName(InstanceDescriptor descriptor, string fileExtension) + { + string name = Importer.EncodeFileName(descriptor.FullName, fileNames); + return Path.Combine(outputDirPath, name + fileExtension); + } + } +} Index: /OniSplit/Game/CharacterClass.cs =================================================================== --- /OniSplit/Game/CharacterClass.cs (revision 1114) +++ /OniSplit/Game/CharacterClass.cs (revision 1114) @@ -0,0 +1,122 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Oni.Game +{ + internal class CharacterClass + { + public InstanceDescriptor Body; + public InstanceDescriptor[] Textures; + public IEnumerable Animations; + public InstanceDescriptor Animation; + + public static CharacterClass Read(InstanceDescriptor descriptor) + { + return Read(descriptor, null); + } + + public static CharacterClass Read(InstanceDescriptor descriptor, string animationName) + { + if (descriptor.Template.Tag != TemplateTag.ONCC) + throw new ArgumentException(string.Format("The specified descriptor has a wrong template {0}", descriptor.Template.Tag), "descriptor"); + + var character = new CharacterClass(); + + InstanceDescriptor trma; + InstanceDescriptor trac; + + using (var reader = descriptor.OpenRead(0xC34)) + { + character.Body = reader.ReadInstance(); + trma = reader.ReadInstance(); + reader.Skip(0x44); + trac = reader.ReadInstance(); + } + + if (trma != null) + { + using (var reader = trma.OpenRead(22)) + character.Textures = reader.ReadInstanceArray(reader.ReadUInt16()); + } + + var animationList = new List(); + + while (trac != null) + { + InstanceDescriptor childCollection; + + using (var reader = trac.OpenRead(16)) + { + childCollection = reader.ReadInstance(); + reader.Skip(2); + int count = reader.ReadUInt16(); + + for (int i = 0; i < count; i++) + { + reader.Skip(8); + var tram = reader.ReadInstance(); + + if (tram != null) + animationList.Add(tram); + } + } + + trac = childCollection; + } + + character.Animations = animationList; + + if (string.Equals(Path.GetExtension(animationName), ".oni", StringComparison.OrdinalIgnoreCase)) + { + var file = descriptor.File.FileManager.OpenFile(animationName); + + if (file != null && file.Descriptors[0].Template.Tag == TemplateTag.TRAM) + character.Animation = file.Descriptors[0]; + } + else + { + if (!string.IsNullOrEmpty(animationName) && !animationName.StartsWith("TRAM", StringComparison.Ordinal)) + animationName = "TRAM" + animationName; + + foreach (var tram in animationList) + { + using (var animReader = tram.OpenRead(0x15A)) + { + int type = animReader.ReadInt16(); + animReader.Skip(2); + int fromState = animReader.ReadInt16(); + int toState = animReader.ReadInt16(); + animReader.Skip(6); + int varient = animReader.ReadInt16(); + + if (!string.IsNullOrEmpty(animationName)) + { + if (tram.FullName == animationName) + { + character.Animation = tram; + break; + } + } + else + { + if (type == 6 + && fromState == 7 + && toState == 7 + && varient == 0) + { + character.Animation = tram; + break; + } + } + } + } + + if (!string.IsNullOrEmpty(animationName) && character.Animation == null) + Console.Error.WriteLine("Animation {0} was not found", animationName); + } + + return character; + } + } +} Index: /OniSplit/Game/WeaponClass.cs =================================================================== --- /OniSplit/Game/WeaponClass.cs (revision 1114) +++ /OniSplit/Game/WeaponClass.cs (revision 1114) @@ -0,0 +1,24 @@ +using System; + +namespace Oni.Game +{ + internal class WeaponClass + { + private InstanceDescriptor geometry; + + public static WeaponClass Read(InstanceDescriptor descriptor) + { + if (descriptor.Template.Tag != TemplateTag.ONWC) + throw new ArgumentException(string.Format("The specified descriptor has a wrong template {0}", descriptor.Template.Tag), "descriptor"); + + var weapon = new WeaponClass(); + + using (var reader = descriptor.OpenRead(0x58)) + weapon.geometry = reader.ReadInstance(); + + return weapon; + } + + public InstanceDescriptor Geometry => geometry; + } +} Index: /OniSplit/Imaging/Color.cs =================================================================== --- /OniSplit/Imaging/Color.cs (revision 1114) +++ /OniSplit/Imaging/Color.cs (revision 1114) @@ -0,0 +1,254 @@ +using System; +using System.Globalization; + +namespace Oni.Imaging +{ + internal struct Color : IEquatable + { + private byte b, g, r, a; + + public Color(byte r, byte g, byte b) + : this(r, g, b, 255) + { + } + + public Color(byte r, byte g, byte b, byte a) + { + this.b = b; + this.g = g; + this.r = r; + this.a = a; + } + + public Color(Vector3 v) + { + r = (byte)(v.X * 255.0f); + g = (byte)(v.Y * 255.0f); + b = (byte)(v.Z * 255.0f); + a = 255; + } + + public Color(Vector4 v) + { + r = (byte)(v.X * 255.0f); + g = (byte)(v.Y * 255.0f); + b = (byte)(v.Z * 255.0f); + a = (byte)(v.W * 255.0f); + } + + public bool IsTransparent => a != 255; + + public byte R => r; + public byte G => g; + public byte B => b; + public byte A => a; + + public int ToBgra32() => b | (g << 8) | (r << 16) | (a << 24); + public int ToBgr565() => (b >> 3) | ((g & 0xfc) << 3) | ((r & 0xf8) << 8); + + public Vector3 ToVector3() => new Vector3(r, g, b) / 255.0f; + public Vector4 ToVector4() => new Vector4(r, g, b, a) / 255.0f; + + public static bool operator ==(Color a, Color b) => a.Equals(b); + public static bool operator !=(Color a, Color b) => !a.Equals(b); + + public bool Equals(Color color) => r == color.r && g == color.g && b == color.b && a == color.a; + public override bool Equals(object obj) => obj is Color && Equals((Color)obj); + public override int GetHashCode() => r.GetHashCode() ^ g.GetHashCode() ^ b.GetHashCode() ^ a.GetHashCode(); + + public override string ToString() => string.Format(CultureInfo.InvariantCulture, "{{R:{0} G:{1} B:{2} A:{3}}}", new object[] { r, g, b, a }); + + public static Color ReadBgra4444(byte[] data, int index) + { + int pixel = data[index + 0]; + byte b = (byte)((pixel << 4) & 0xf0); + byte g = (byte)(pixel & 0xf0); + pixel = data[index + 1]; + byte r = (byte)((pixel << 4) & 0xf0); + byte a = (byte)(pixel & 0xf0); + + return new Color(r, g, b, a); + } + + public static void WriteBgra4444(Color color, byte[] data, int index) + { + data[index + 0] = (byte)((color.b >> 4) | (color.g & 0xf0)); + data[index + 1] = (byte)((color.r >> 4) | (color.a & 0xf0)); + } + + public static Color ReadBgrx5551(byte[] data, int index) + { + int pixel = data[index + 0] | (data[index + 1] << 8); + byte b = (byte)((pixel << 3) & 0xf8); + byte g = (byte)((pixel >> 2) & 0xf8); + byte r = (byte)((pixel >> 7) & 0xf8); + + return new Color(r, g, b); + } + + public static void WriteBgrx5551(Color color, byte[] data, int index) + { + data[index + 0] = (byte)((color.b >> 3) | ((color.g & 0x38) << 2)); + data[index + 1] = (byte)((color.g >> 6) | ((color.r & 0xf8) >> 1) | 0x80); + } + + public static Color ReadBgra5551(byte[] data, int index) + { + int pixel = data[index + 0] | (data[index + 1] << 8); + byte b = (byte)((pixel << 3) & 0xf8); + byte g = (byte)((pixel >> 2) & 0xf8); + byte r = (byte)((pixel >> 7) & 0xf8); + byte a = (byte)((pixel >> 15) * 255); + + return new Color(r, g, b, a); + } + + public static void WriteBgra5551(Color color, byte[] data, int index) + { + data[index + 0] = (byte)((color.b >> 3) | ((color.g & 0x38) << 2)); + data[index + 1] = (byte)((color.g >> 6) | ((color.r & 0xf8) >> 1) | (color.a & 0x80)); + } + + public static Color ReadBgr565(byte[] data, int index) + { + int pixel = data[index + 0] | (data[index + 1] << 8); + byte b = (byte)((pixel << 3) & 0xf8); + byte g = (byte)((pixel >> 3) & 0xfc); + byte r = (byte)((pixel >> 8) & 0xf8); + + return new Color(r, g, b); + } + + public static void WriteBgr565(Color color, byte[] data, int index) + { + data[index + 0] = (byte)((color.b >> 3) | ((color.g & 0x1C) << 3)); + data[index + 1] = (byte)((color.g >> 5) | (color.r & 0xf8)); + } + + public static Color ReadBgrx(byte[] data, int index) + { + byte b = data[index + 0]; + byte g = data[index + 1]; + byte r = data[index + 2]; + + return new Color(r, g, b); + } + + public static void WriteBgrx(Color color, byte[] data, int index) + { + data[index + 0] = color.b; + data[index + 1] = color.g; + data[index + 2] = color.r; + data[index + 3] = 255; + } + + public static Color ReadBgra(byte[] data, int index) + { + byte b = data[index + 0]; + byte g = data[index + 1]; + byte r = data[index + 2]; + byte a = data[index + 3]; + + return new Color(r, g, b, a); + } + + public static void WriteBgra(Color color, byte[] data, int index) + { + data[index + 0] = color.b; + data[index + 1] = color.g; + data[index + 2] = color.r; + data[index + 3] = color.a; + } + + public static Color ReadRgbx(byte[] data, int index) + { + byte r = data[index + 0]; + byte g = data[index + 1]; + byte b = data[index + 2]; + + return new Color(r, g, b); + } + + public static void WriteRgbx(Color color, byte[] data, int index) + { + data[index + 0] = color.r; + data[index + 1] = color.g; + data[index + 2] = color.b; + data[index + 3] = 255; + } + + public static Color ReadRgba(byte[] data, int index) + { + byte r = data[index + 0]; + byte g = data[index + 1]; + byte b = data[index + 2]; + byte a = data[index + 3]; + + return new Color(r, g, b, a); + } + + public static void WriteRgba(Color color, byte[] data, int index) + { + data[index + 0] = color.r; + data[index + 1] = color.g; + data[index + 2] = color.b; + data[index + 3] = color.a; + } + + public static Color Lerp(Color x, Color y, float amount) + { + byte r = (byte)MathHelper.Lerp(x.r, y.r, amount); + byte g = (byte)MathHelper.Lerp(x.g, y.g, amount); + byte b = (byte)MathHelper.Lerp(x.b, y.b, amount); + byte a = (byte)MathHelper.Lerp(x.a, y.a, amount); + + return new Color(r, g, b, a); + } + + private static readonly Color black = new Color(0, 0, 0, 255); + private static readonly Color white = new Color(255, 255, 255, 255); + private static readonly Color transparent = new Color(0, 0, 0, 0); + + public static Color White => white; + public static Color Black => black; + public static Color Transparent => transparent; + + public static bool TryParse(string s, out Color color) + { + color = new Color(); + color.a = 255; + + if (string.IsNullOrEmpty(s)) + return false; + + var tokens = s.Split(new char[0], StringSplitOptions.RemoveEmptyEntries); + + if (tokens.Length < 3 || tokens.Length > 4) + return false; + + if (!byte.TryParse(tokens[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out color.r)) + return false; + + if (!byte.TryParse(tokens[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out color.g)) + return false; + + if (!byte.TryParse(tokens[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out color.b)) + return false; + + if (tokens.Length > 3 && !byte.TryParse(tokens[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out color.a)) + return false; + + return true; + } + + public static Color Parse(string s) + { + Color c; + + if (!TryParse(s, out c)) + throw new FormatException(string.Format("'{0}' is not a color", s)); + + return c; + } + } +} Index: /OniSplit/Imaging/DdsHeader.cs =================================================================== --- /OniSplit/Imaging/DdsHeader.cs (revision 1114) +++ /OniSplit/Imaging/DdsHeader.cs (revision 1114) @@ -0,0 +1,315 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Oni.Imaging +{ + internal class DdsHeader + { + #region Private data + + private enum FOURCC + { + FOURCC_NONE = 0, + FOURCC_DXT1 = 0x31545844 + } + + [Flags] + private enum DDS_FLAGS + { + DDSD_CAPS = 0x00000001, + DDSD_HEIGHT = 0x00000002, + DDSD_WIDTH = 0x00000004, + DDSD_PITCH = 0x00000008, + DDSD_PIXELFORMAT = 0x00001000, + DDSD_MIPMAPCOUNT = 0x00020000, + DDSD_LINEARSIZE = 0x00080000, + DDSD_DEPTH = 0x00800000 + } + + [Flags] + private enum DDP_FLAGS + { + DDPF_RGB = 0x00000040, + DDPF_FOURCC = 0x00000004, + DDPF_ALPHAPIXELS = 0x00000001 + } + + [Flags] + private enum DDS_CAPS + { + DDSCAPS_TEXTURE = 0x00001000, + DDSCAPS_MIPMAP = 0x00400000, + DDSCAPS_COMPLEX = 0x00000008 + } + + [Flags] + private enum DDS_CAPS2 + { + DDSCAPS2_CUBEMAP = 0x00000200, + DDSCAPS2_VOLUME = 0x00200000 + } + + private const int DDS_MAGIC = 0x20534444; + + private DDS_FLAGS flags; + private int height; + private int width; + private int linearSize; + private int depth; + private int mipmapCount; + private DDP_FLAGS formatFlags; + private FOURCC fourCC; + private int rgbBitCount; + private uint rBitMask; + private uint gBitMask; + private uint bBitMask; + private uint aBitMask; + private DDS_CAPS caps; + private DDS_CAPS2 caps2; + #endregion + + public int Width => width; + public int Height => height; + public int MipmapCount => mipmapCount; + + public SurfaceFormat GetSurfaceFormat() + { + if (fourCC == FOURCC.FOURCC_DXT1) + return SurfaceFormat.DXT1; + + if (rgbBitCount == 32) + { + if (rBitMask == 0x00ff0000 && gBitMask == 0x0000ff00 && bBitMask == 0x000000ff) + { + if ((formatFlags & DDP_FLAGS.DDPF_ALPHAPIXELS) == 0) + return SurfaceFormat.BGRX; + + if (aBitMask == 0xff000000) + return SurfaceFormat.BGRA; + } + } + else if (rgbBitCount == 16) + { + if (rBitMask == 0x7c00 && gBitMask == 0x03e0 && bBitMask == 0x001f) + { + if ((formatFlags & DDP_FLAGS.DDPF_ALPHAPIXELS) == 0) + return SurfaceFormat.BGRX5551; + + if (aBitMask == 0x8000) + return SurfaceFormat.BGRA5551; + } + else if (rBitMask == 0x0f00 && gBitMask == 0x00f0 && bBitMask == 0x000f) + { + if ((formatFlags & DDP_FLAGS.DDPF_ALPHAPIXELS) != 0) + return SurfaceFormat.BGRA4444; + } + } + + throw new NotSupportedException(string.Format("Unsupported pixel format {0} {1} {2} {3} {4} {5} {6}", + formatFlags, + fourCC, rgbBitCount, + rBitMask, gBitMask, bBitMask, aBitMask)); + } + + public static DdsHeader Read(BinaryReader reader) + { + if (reader.ReadInt32() != DDS_MAGIC) + throw new InvalidDataException("Not a DDS file"); + + var header = new DdsHeader(); + + if (reader.ReadInt32() != 124) + throw new InvalidDataException("Invalid DDS header size"); + + header.flags = (DDS_FLAGS)reader.ReadInt32(); + + var requiredFlags = DDS_FLAGS.DDSD_CAPS | DDS_FLAGS.DDSD_HEIGHT | DDS_FLAGS.DDSD_WIDTH | DDS_FLAGS.DDSD_PIXELFORMAT; + + if ((header.flags & requiredFlags) != requiredFlags) + throw new InvalidDataException(string.Format("Invalid DDS header flags ({0})", header.flags)); + + header.height = reader.ReadInt32(); + header.width = reader.ReadInt32(); + + if (header.width == 0 || header.height == 0) + throw new InvalidDataException("DDS file has 0 width or height"); + + header.linearSize = reader.ReadInt32(); + header.depth = reader.ReadInt32(); + + if ((header.flags & DDS_FLAGS.DDSD_MIPMAPCOUNT) != 0) + { + header.mipmapCount = reader.ReadInt32(); + } + else + { + reader.ReadInt32(); + header.mipmapCount = 1; + } + + reader.Position += 44; + + if (reader.ReadInt32() != 32) + throw new InvalidDataException("Invalid DDS pixel format size"); + + header.formatFlags = (DDP_FLAGS)reader.ReadInt32(); + + if ((header.formatFlags & DDP_FLAGS.DDPF_FOURCC) != 0) + { + header.fourCC = (FOURCC)reader.ReadInt32(); + } + else + { + reader.ReadInt32(); + header.fourCC = FOURCC.FOURCC_NONE; + } + + header.rgbBitCount = reader.ReadInt32(); + header.rBitMask = reader.ReadUInt32(); + header.gBitMask = reader.ReadUInt32(); + header.bBitMask = reader.ReadUInt32(); + header.aBitMask = reader.ReadUInt32(); + + header.caps = (DDS_CAPS)reader.ReadInt32(); + header.caps2 = (DDS_CAPS2)reader.ReadInt32(); + + reader.Position += 12; + + if (header.fourCC == FOURCC.FOURCC_NONE) + { + if (header.rgbBitCount != 16 && header.rgbBitCount != 32) + throw new NotSupportedException(string.Format("Unsupported RGB bit count {0}", header.rgbBitCount)); + } + else if (header.fourCC != FOURCC.FOURCC_DXT1) + { + throw new NotSupportedException(string.Format("Unsupported FOURCC {0}", header.fourCC)); + } + + return header; + } + + public static DdsHeader Create(IList surfaces) + { + var header = new DdsHeader(); + + int width = surfaces[0].Width; + int height = surfaces[0].Height; + var format = surfaces[0].Format; + + header.flags = DDS_FLAGS.DDSD_CAPS | DDS_FLAGS.DDSD_HEIGHT | DDS_FLAGS.DDSD_WIDTH | DDS_FLAGS.DDSD_PIXELFORMAT; + header.width = width; + header.height = height; + header.caps = DDS_CAPS.DDSCAPS_TEXTURE; + + switch (format) + { + case SurfaceFormat.BGRA4444: + header.formatFlags = DDP_FLAGS.DDPF_RGB | DDP_FLAGS.DDPF_ALPHAPIXELS; + header.rgbBitCount = 16; + header.aBitMask = 0xf000; + header.rBitMask = 0x0f00; + header.gBitMask = 0x00f0; + header.bBitMask = 0x000f; + break; + case SurfaceFormat.BGRX5551: + case SurfaceFormat.BGRA5551: + header.formatFlags = DDP_FLAGS.DDPF_RGB | DDP_FLAGS.DDPF_ALPHAPIXELS; + header.rgbBitCount = 16; + header.aBitMask = 0x8000; + header.rBitMask = 0x7c00; + header.gBitMask = 0x03e0; + header.bBitMask = 0x001f; + break; + case SurfaceFormat.BGRA: + header.formatFlags = DDP_FLAGS.DDPF_RGB | DDP_FLAGS.DDPF_ALPHAPIXELS; + header.rgbBitCount = 32; + header.aBitMask = 0xff000000; + header.rBitMask = 0x00ff0000; + header.gBitMask = 0x0000ff00; + header.bBitMask = 0x000000ff; + break; + case SurfaceFormat.BGRX: + header.formatFlags = DDP_FLAGS.DDPF_RGB; + header.rgbBitCount = 32; + header.rBitMask = 0x00ff0000; + header.gBitMask = 0x0000ff00; + header.bBitMask = 0x000000ff; + break; + case SurfaceFormat.RGBA: + header.formatFlags = DDP_FLAGS.DDPF_RGB | DDP_FLAGS.DDPF_ALPHAPIXELS; + header.rgbBitCount = 32; + header.aBitMask = 0x000000ff; + header.rBitMask = 0x0000ff00; + header.gBitMask = 0x00ff0000; + header.bBitMask = 0xff000000; + break; + case SurfaceFormat.RGBX: + header.formatFlags = DDP_FLAGS.DDPF_RGB; + header.rgbBitCount = 32; + header.rBitMask = 0x0000ff00; + header.gBitMask = 0x00ff0000; + header.bBitMask = 0xff000000; + break; + case SurfaceFormat.DXT1: + header.formatFlags = DDP_FLAGS.DDPF_FOURCC; + header.fourCC = FOURCC.FOURCC_DXT1; + break; + } + + switch (format) + { + case SurfaceFormat.BGRA4444: + case SurfaceFormat.BGRX5551: + case SurfaceFormat.BGRA5551: + header.flags |= DDS_FLAGS.DDSD_PITCH; + header.linearSize = width * 2; + break; + case SurfaceFormat.BGRX: + case SurfaceFormat.BGRA: + case SurfaceFormat.RGBA: + case SurfaceFormat.RGBX: + header.flags |= DDS_FLAGS.DDSD_PITCH; + header.linearSize = width * 4; + break; + case SurfaceFormat.DXT1: + header.flags |= DDS_FLAGS.DDSD_LINEARSIZE; + header.linearSize = Math.Max(1, width / 4) * Math.Max(1, height / 4) * 8; + break; + } + + if (surfaces.Count > 1) + { + header.flags |= DDS_FLAGS.DDSD_MIPMAPCOUNT; + header.mipmapCount = surfaces.Count; + header.caps |= DDS_CAPS.DDSCAPS_COMPLEX | DDS_CAPS.DDSCAPS_MIPMAP; + } + + return header; + } + + public void Write(BinaryWriter writer) + { + writer.Write(DDS_MAGIC); + writer.Write(124); + writer.Write((int)flags); + writer.Write(height); + writer.Write(width); + writer.Write(linearSize); + writer.Write(depth); + writer.Write(mipmapCount); + writer.BaseStream.Seek(44, SeekOrigin.Current); + writer.Write(32); + writer.Write((int)formatFlags); + writer.Write((int)fourCC); + writer.Write(rgbBitCount); + writer.Write(rBitMask); + writer.Write(gBitMask); + writer.Write(bBitMask); + writer.Write(aBitMask); + writer.Write((int)caps); + writer.Write((int)caps2); + writer.BaseStream.Seek(12, SeekOrigin.Current); + } + } +} Index: /OniSplit/Imaging/DdsReader.cs =================================================================== --- /OniSplit/Imaging/DdsReader.cs (revision 1114) +++ /OniSplit/Imaging/DdsReader.cs (revision 1114) @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Imaging +{ + internal static class DdsReader + { + public static List Read(string filePath, bool noMipMaps) + { + var surfaces = new List(); + + using (var reader = new BinaryReader(filePath)) + { + var header = DdsHeader.Read(reader); + var format = header.GetSurfaceFormat(); + + for (int i = 0; i < header.MipmapCount; i++) + { + int width = Math.Max(header.Width >> i, 1); + int height = Math.Max(header.Height >> i, 1); + + if (format == SurfaceFormat.DXT1) + { + width = Math.Max(width, 4); + height = Math.Max(height, 4); + } + + var surface = new Surface(width, height, format); + reader.Read(surface.Data, 0, surface.Data.Length); + surfaces.Add(surface); + + if (noMipMaps) + break; + } + } + + return surfaces; + } + } +} Index: /OniSplit/Imaging/DdsWriter.cs =================================================================== --- /OniSplit/Imaging/DdsWriter.cs (revision 1114) +++ /OniSplit/Imaging/DdsWriter.cs (revision 1114) @@ -0,0 +1,23 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Oni.Imaging +{ + internal class DdsWriter + { + public static void Write(IList surfaces, string filePath) + { + using (var stream = File.Create(filePath)) + using (var writer = new BinaryWriter(stream)) + { + var header = DdsHeader.Create(surfaces); + + header.Write(writer); + + foreach (var surface in surfaces) + writer.Write(surface.Data); + } + } + } +} Index: /OniSplit/Imaging/Dxt1.cs =================================================================== --- /OniSplit/Imaging/Dxt1.cs (revision 1114) +++ /OniSplit/Imaging/Dxt1.cs (revision 1114) @@ -0,0 +1,144 @@ +using System; + +namespace Oni.Imaging +{ + internal static class Dxt1 + { + public static Surface Decompress(Surface src, SurfaceFormat dstFormat) + { + var dst = new Surface(src.Width, src.Height, dstFormat); + var colors = new Color[4]; + int srcOffset = 0; + + for (int y = 0; y < dst.Height; y += 4) + { + for (int x = 0; x < dst.Width; x += 4) + { + colors[0] = Color.ReadBgr565(src.Data, srcOffset); + srcOffset += 2; + + colors[1] = Color.ReadBgr565(src.Data, srcOffset); + srcOffset += 2; + + if (colors[0].ToBgr565() > colors[1].ToBgr565()) + { + colors[2] = Color.Lerp(colors[0], colors[1], 1.0f / 3.0f); + colors[3] = Color.Lerp(colors[0], colors[1], 2.0f / 3.0f); + } + else + { + colors[2] = Color.Lerp(colors[0], colors[1], 0.5f); + colors[3] = Color.Transparent; + } + + for (int y2 = 0; y2 < 4; y2++) + { + int packedLookup = src.Data[srcOffset++]; + + for (int x2 = 0; x2 < 4; x2++) + { + dst[x + x2, y + y2] = colors[packedLookup & 3]; + packedLookup >>= 2; + } + } + } + } + + return dst; + } + + public static Surface Compress(Surface src) + { + var dst = new Surface(Utils.Align4(src.Width), Utils.Align4(src.Height), SurfaceFormat.DXT1); + + var block = new Vector3[16]; + var colors = new Vector3[4]; + var lookup = new int[16]; + int dstOffset = 0; + int height = dst.Height; + int width = dst.Width; + + for (int y = 0; y < height; y += 4) + { + for (int x = 0; x < width; x += 4) + { + for (int by = 0; by < 4; by++) + { + for (int bx = 0; bx < 4; bx++) + block[by * 4 + bx] = src[x + bx, y + by].ToVector3(); + } + + CompressBlock(block, lookup, colors); + + Color.WriteBgr565(new Color(colors[0]), dst.Data, dstOffset); + dstOffset += 2; + + Color.WriteBgr565(new Color(colors[1]), dst.Data, dstOffset); + dstOffset += 2; + + for (int by = 0; by < 4; by++) + { + int packedLookup = 0; + + for (int bx = 3; bx >= 0; bx--) + packedLookup = (packedLookup << 2) | lookup[by * 4 + bx]; + + dst.Data[dstOffset++] = (byte)packedLookup; + } + } + } + + return dst; + } + + private static void CompressBlock(Vector3[] block, int[] lookup, Vector3[] colors) + { + colors[0] = block[0]; + colors[1] = block[0]; + + for (int i = 1; i < block.Length; i++) + { + colors[0] = Vector3.Min(colors[0], block[i]); + colors[1] = Vector3.Max(colors[1], block[i]); + } + + int maxColor; + + if (new Color(colors[0]).ToBgr565() > new Color(colors[1]).ToBgr565()) + { + colors[2] = Vector3.Lerp(colors[0], colors[1], 1.0f / 3.0f); + colors[3] = Vector3.Lerp(colors[0], colors[1], 2.0f / 3.0f); + maxColor = 4; + } + else + { + colors[2] = Vector3.Lerp(colors[0], colors[1], 0.5f); + maxColor = 3; + } + + for (int i = 0; i < block.Length; i++) + { + lookup[i] = LookupNearest(colors, block[i], maxColor); + } + } + + private static int LookupNearest(Vector3[] colors, Vector3 pixel, int maxColor) + { + int index = 0; + float ds = Vector3.DistanceSquared(pixel, colors[0]); + + for (int i = 1; i < maxColor; i++) + { + float newDs = Vector3.DistanceSquared(pixel, colors[i]); + + if (newDs < ds) + { + ds = newDs; + index = i; + } + } + + return index; + } + } +} Index: /OniSplit/Imaging/Point.cs =================================================================== --- /OniSplit/Imaging/Point.cs (revision 1114) +++ /OniSplit/Imaging/Point.cs (revision 1114) @@ -0,0 +1,27 @@ +namespace Oni.Imaging +{ + internal struct Point + { + public static readonly Point UnitX = new Point(1, 0); + public static readonly Point UnitY = new Point(0, 1); + + public int X; + public int Y; + + public Point(int x, int y) + { + X = x; + Y = y; + } + + public static Point operator +(Point p0, Point p1) => new Point(p0.X + p1.X, p0.Y + p1.Y); + public static Point operator -(Point p0, Point p1) => new Point(p0.X - p1.X, p0.Y - p1.Y); + + public static bool operator ==(Point p0, Point p1) => p0.X == p1.X && p0.Y == p1.Y; + public static bool operator !=(Point p0, Point p1) => p0.X != p1.X || p0.Y != p1.Y; + + public override bool Equals(object obj) => obj is Point && ((Point)obj) == this; + + public override int GetHashCode() => X.GetHashCode() ^ Y.GetHashCode(); + } +} Index: /OniSplit/Imaging/Surface.cs =================================================================== --- /OniSplit/Imaging/Surface.cs (revision 1114) +++ /OniSplit/Imaging/Surface.cs (revision 1114) @@ -0,0 +1,426 @@ +using System; + +namespace Oni.Imaging +{ + internal class Surface + { + private int width; + private int height; + private int stride; + private int pixelSize; + private SurfaceFormat format; + private byte[] data; + + public Surface(int width, int height) + : this(width, height, SurfaceFormat.RGBA) + { + } + + public Surface(int width, int height, SurfaceFormat format) + { + if (format == SurfaceFormat.DXT1) + { + width = Math.Max(width, 4); + height = Math.Max(height, 4); + } + + this.width = width; + this.height = height; + this.format = format; + + pixelSize = GetPixelSize(format); + stride = pixelSize * width; + data = new byte[GetDataSize(width, height, format)]; + } + + public Surface(int width, int height, SurfaceFormat format, byte[] data) + { + if (format == SurfaceFormat.DXT1) + { + width = Math.Max(width, 4); + height = Math.Max(height, 4); + } + + this.width = width; + this.height = height; + this.format = format; + this.data = data; + + pixelSize = GetPixelSize(format); + stride = pixelSize * width; + } + + private static int GetDataSize(int width, int height, SurfaceFormat format) + { + switch (format) + { + case SurfaceFormat.BGRA4444: + case SurfaceFormat.BGRX5551: + case SurfaceFormat.BGRA5551: + return width * height * 2; + + case SurfaceFormat.BGRX: + case SurfaceFormat.BGRA: + case SurfaceFormat.RGBX: + case SurfaceFormat.RGBA: + return width * height * 4; + + case SurfaceFormat.DXT1: + return width * height / 2; + + default: + throw new NotSupportedException(string.Format("Unsupported texture format {0}", format)); + } + } + + private static int GetPixelSize(SurfaceFormat format) + { + switch (format) + { + case SurfaceFormat.BGRA4444: + case SurfaceFormat.BGRX5551: + case SurfaceFormat.BGRA5551: + return 2; + + case SurfaceFormat.BGRX: + case SurfaceFormat.BGRA: + case SurfaceFormat.RGBX: + case SurfaceFormat.RGBA: + return 4; + + case SurfaceFormat.DXT1: + return 2; + + default: + throw new NotSupportedException(string.Format("Unsupported texture format {0}", format)); + } + } + + public int Width => width; + public int Height => height; + public SurfaceFormat Format => format; + public byte[] Data => data; + + public bool HasAlpha + { + get + { + switch (format) + { + case SurfaceFormat.BGRA: + case SurfaceFormat.RGBA: + case SurfaceFormat.BGRA4444: + case SurfaceFormat.BGRA5551: + return true; + + default: + return false; + } + } + } + + public void CleanupAlpha() + { + if (format != SurfaceFormat.BGRA5551 && format != SurfaceFormat.RGBA && format != SurfaceFormat.BGRA) + return; + + if (!HasTransparentPixels()) + { + switch (format) + { + case SurfaceFormat.BGRA5551: + format = SurfaceFormat.BGRX5551; + break; + case SurfaceFormat.BGRA: + format = SurfaceFormat.BGRX; + break; + case SurfaceFormat.RGBA: + format = SurfaceFormat.RGBX; + break; + } + } + } + + public bool HasTransparentPixels() + { + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + Color c = GetPixel(x, y); + + if (c.A != 255) + return true; + } + } + + return false; + } + + public Color this[int x, int y] + { + get + { + if (x < 0 || width <= x || y < 0 || height <= y) + return Color.Black; + + return GetPixel(x, y); + } + set + { + if (x < 0 || width <= x || y < 0 || height <= y) + return; + + SetPixel(x, y, value); + } + } + + public void FlipVertical() + { + var temp = new byte[stride]; + + for (int y = 0; y < height / 2; y++) + { + int ry = height - y - 1; + + Array.Copy(data, y * stride, temp, 0, stride); + Array.Copy(data, ry * stride, data, y * stride, stride); + Array.Copy(temp, 0, data, ry * stride, stride); + } + } + + public void FlipHorizontal() + { + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width / 2; x++) + { + int rx = width - x - 1; + + Color c1 = GetPixel(x, y); + Color c2 = GetPixel(rx, y); + SetPixel(x, y, c2); + SetPixel(rx, y, c1); + } + } + } + + public void Rotate90() + { + for (int x = 0; x < width; x++) + { + for (int y = 0; y < height; y++) + { + if (x <= y) + continue; + + var c1 = GetPixel(x, y); + var c2 = GetPixel(y, x); + SetPixel(x, y, c2); + SetPixel(y, x, c1); + } + } + } + + public Surface Convert(SurfaceFormat dstFormat) + { + Surface dst; + + if (format == dstFormat) + { + dst = new Surface(width, height, dstFormat, (byte[])data.Clone()); + } + else if (dstFormat == SurfaceFormat.DXT1) + { + dst = Dxt1.Compress(this); + } + else if (format == SurfaceFormat.DXT1) + { + dst = Dxt1.Decompress(this, dstFormat); + } + else + { + dst = new Surface(width, height, dstFormat); + + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + dst.SetPixel(x, y, GetPixel(x, y)); + } + } + + return dst; + } + + public Surface Resize(int newWidth, int newHeight) + { + if (newWidth > width || newHeight > height) + throw new NotImplementedException(); + + var dst = new Surface(newWidth, newHeight, format); + + if (newWidth * 2 == width && newHeight * 2 == height) + { + Halfsize(dst); + return dst; + } + + float sx = (float)width / dst.width; + float sy = (float)height / dst.height; + + for (int dstY = 0; dstY < dst.height; dstY++) + { + float top = dstY * sy; + float bottom = top + sy; + + int yTop = (int)top; + int yBottom = (int)(bottom - 0.001f); + + float topWeight = 1.0f - (top - yTop); + float bottomWeight = bottom - yBottom; + + for (int dstX = 0; dstX < dst.width; dstX++) + { + float left = dstX * sx; + float right = left + sx; + + int xLeft = (int)left; + int xRight = (int)(right - 0.001f); + + float leftWeight = 1.0f - (left - xLeft); + float rightWeight = right - xRight; + + var sum = GetVector4(xLeft, yTop) * (leftWeight * topWeight); + sum += GetVector4(xRight, yTop) * (rightWeight * topWeight); + sum += GetVector4(xLeft, yBottom) * (leftWeight * bottomWeight); + sum += GetVector4(xRight, yBottom) * (rightWeight * bottomWeight); + + for (int y = yTop + 1; y < yBottom; y++) + { + sum += GetVector4(xLeft, y) * leftWeight; + sum += GetVector4(xRight, y) * rightWeight; + } + + for (int x = xLeft + 1; x < xRight; x++) + { + sum += GetVector4(x, yTop) * topWeight; + sum += GetVector4(x, yBottom) * bottomWeight; + } + + for (int y = yTop + 1; y < yBottom; y++) + { + for (int x = xLeft + 1; x < xRight; x++) + sum += GetVector4(x, y); + } + + float area = (right - left) * (bottom - top); + + dst.SetPixel(dstX, dstY, new Color(sum / area)); + } + } + + return dst; + } + + private void Halfsize(Surface dst) + { + int halfWidth = dst.width; + int halfHeight = dst.height; + + for (int dstY = 0; dstY < halfHeight; dstY++) + { + int yTop = dstY * 2; + int yBottom = yTop + 1; + + for (int dstX = 0; dstX < halfWidth; dstX++) + { + int xLeft = dstX * 2; + int xRight = xLeft + 1; + + var sum = GetVector4(xLeft, yTop); + sum += GetVector4(xRight, yTop); + sum += GetVector4(xLeft, yBottom); + sum += GetVector4(xRight, yBottom); + + dst.SetPixel(dstX, dstY, new Color(sum / 4.0f)); + } + } + } + + private Vector4 GetVector4(int x, int y) + { + return GetPixel(x, y).ToVector4(); + } + + private Color GetPixel(int x, int y) + { + int i = x * pixelSize + y * stride; + + switch (format) + { + case SurfaceFormat.BGRA4444: + return Color.ReadBgra4444(data, i); + case SurfaceFormat.BGRX5551: + return Color.ReadBgrx5551(data, i); + case SurfaceFormat.BGRA5551: + return Color.ReadBgra5551(data, i); + case SurfaceFormat.BGR565: + return Color.ReadBgr565(data, i); + case SurfaceFormat.BGRX: + return Color.ReadBgrx(data, i); + case SurfaceFormat.BGRA: + return Color.ReadBgra(data, i); + case SurfaceFormat.RGBX: + return Color.ReadRgbx(data, i); + case SurfaceFormat.RGBA: + return Color.ReadRgba(data, i); + default: + throw new NotSupportedException(string.Format("Unsupported texture format {0}", format)); + } + } + + private void SetPixel(int x, int y, Color color) + { + int i = x * pixelSize + y * stride; + + switch (format) + { + case SurfaceFormat.BGRA4444: + Color.WriteBgra4444(color, data, i); + return; + case SurfaceFormat.BGRX5551: + Color.WriteBgrx5551(color, data, i); + return; + case SurfaceFormat.BGRA5551: + Color.WriteBgra5551(color, data, i); + return; + case SurfaceFormat.BGR565: + Color.WriteBgr565(color, data, i); + return; + case SurfaceFormat.BGRX: + Color.WriteBgrx(color, data, i); + return; + case SurfaceFormat.BGRA: + Color.WriteBgra(color, data, i); + return; + case SurfaceFormat.RGBX: + Color.WriteRgbx(color, data, i); + return; + case SurfaceFormat.RGBA: + Color.WriteRgba(color, data, i); + return; + default: + throw new NotSupportedException(string.Format("Unsupported texture format {0}", format)); + } + } + + public void Fill(int x, int y, int width, int height, Color color) + { + for (int px = x; px < x + width; px++) + { + for (int py = y; py < y + height; py++) + SetPixel(px, py, color); + } + } + } +} Index: /OniSplit/Imaging/SurfaceFormat.cs =================================================================== --- /OniSplit/Imaging/SurfaceFormat.cs (revision 1114) +++ /OniSplit/Imaging/SurfaceFormat.cs (revision 1114) @@ -0,0 +1,15 @@ +namespace Oni.Imaging +{ + internal enum SurfaceFormat + { + BGRA4444, + BGRX5551, + BGRA5551, + BGR565, + BGRX, + BGRA, + RGBX, + RGBA, + DXT1 + } +} Index: /OniSplit/Imaging/SysReader.cs =================================================================== --- /OniSplit/Imaging/SysReader.cs (revision 1114) +++ /OniSplit/Imaging/SysReader.cs (revision 1114) @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Drawing.Imaging; +using System.Runtime.InteropServices; + +namespace Oni.Imaging +{ + internal static class SysReader + { + public static Surface Read(string filePath) + { + using (Bitmap bmp = new Bitmap(filePath, false)) + { + SurfaceFormat surfaceFormat; + PixelFormat pixelFormat; + + if (bmp.RawFormat == ImageFormat.Jpeg || bmp.RawFormat == ImageFormat.Bmp) + { + surfaceFormat = SurfaceFormat.BGRX; + pixelFormat = PixelFormat.Format32bppRgb; + } + else + { + surfaceFormat = SurfaceFormat.BGRA; + pixelFormat = PixelFormat.Format32bppArgb; + } + + var surface = new Surface(bmp.Width, bmp.Height, surfaceFormat); + var rc = new Rectangle(0, 0, bmp.Width, bmp.Height); + + var data = bmp.LockBits(rc, ImageLockMode.ReadOnly, pixelFormat); + Marshal.Copy(data.Scan0, surface.Data, 0, surface.Data.Length); + bmp.UnlockBits(data); + + return surface; + } + } + } +} Index: /OniSplit/Imaging/SysWriter.cs =================================================================== --- /OniSplit/Imaging/SysWriter.cs (revision 1114) +++ /OniSplit/Imaging/SysWriter.cs (revision 1114) @@ -0,0 +1,43 @@ +using System; +using System.Drawing; +using System.Drawing.Imaging; +using System.IO; +using System.Runtime.InteropServices; + +namespace Oni.Imaging +{ + internal class SysWriter + { + public static void Write(Surface surface, string filePath) + { + Directory.CreateDirectory(Path.GetDirectoryName(filePath)); + + surface = surface.Convert(SurfaceFormat.BGRA); + + using (var bitmap = new Bitmap(surface.Width, surface.Height, PixelFormat.Format32bppArgb)) + { + var rc = new Rectangle(0, 0, surface.Width, surface.Height); + + var pixels = bitmap.LockBits(rc, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); + Marshal.Copy(surface.Data, 0, pixels.Scan0, surface.Data.Length); + bitmap.UnlockBits(pixels); + + switch (Path.GetExtension(filePath)) + { + case ".png": + bitmap.Save(filePath, ImageFormat.Png); + break; + case ".jpg": + bitmap.Save(filePath, ImageFormat.Jpeg); + break; + case ".bmp": + bitmap.Save(filePath, ImageFormat.Bmp); + break; + case ".tif": + bitmap.Save(filePath, ImageFormat.Tiff); + break; + } + } + } + } +} Index: /OniSplit/Imaging/TgaHeader.cs =================================================================== --- /OniSplit/Imaging/TgaHeader.cs (revision 1114) +++ /OniSplit/Imaging/TgaHeader.cs (revision 1114) @@ -0,0 +1,163 @@ +using System; +using System.IO; + +namespace Oni.Imaging +{ + internal class TgaHeader + { + #region Private data + private bool hasColorMap; + private TgaImageType imageType; + private int colorMapIndex; + private int colorMapLength; + private int colorMapEntrySize; + private int width; + private int height; + private int pixelDepth; + private int imageDescriptor; + private bool xFlip; + private bool yFlip; + private bool hasAlpha; + #endregion + + public TgaImageType ImageType => imageType; + public int Width => width; + public int Height => height; + public int PixelSize => pixelDepth / 8; + public bool XFlip => xFlip; + public bool YFlip => yFlip; + + public static TgaHeader Read(BinaryReader reader) + { + int idLength = reader.ReadByte(); + + var header = new TgaHeader(); + header.hasColorMap = (reader.ReadByte() != 0); + header.imageType = (TgaImageType)reader.ReadByte(); + header.colorMapIndex = reader.ReadUInt16(); + header.colorMapLength = reader.ReadUInt16(); + header.colorMapEntrySize = reader.ReadByte(); + reader.ReadUInt16(); // x origin + reader.ReadUInt16(); // y origin + header.width = reader.ReadUInt16(); + header.height = reader.ReadUInt16(); + header.pixelDepth = reader.ReadByte(); + header.imageDescriptor = reader.ReadByte(); + + if (!Enum.IsDefined(typeof(TgaImageType), header.ImageType) || header.ImageType == TgaImageType.None) + throw new NotSupportedException(string.Format("Unsupported TGA image type {0}", header.ImageType)); + + if (header.Width == 0 || header.Height == 0) + throw new InvalidDataException("Invalid TGA file"); + + if (header.ImageType == TgaImageType.TrueColor + && (header.pixelDepth != 16 + && header.pixelDepth != 24 + && header.pixelDepth != 32)) + { + throw new InvalidDataException(string.Format("Invalid true color pixel depth {0}", header.pixelDepth)); + } + + if (header.hasColorMap) + { + if (header.colorMapEntrySize != 16 + && header.colorMapEntrySize != 24 + && header.colorMapEntrySize != 32) + { + throw new InvalidDataException(string.Format("Invalid color map entry size {0}", header.colorMapEntrySize)); + } + + if (header.ImageType != TgaImageType.ColorMapped + && header.ImageType != TgaImageType.RleColorMapped) + { + // + // We have a color map but the image type does not use it so we'll just skip it. + // + + reader.Position += header.colorMapLength * header.colorMapEntrySize / 8; + } + } + + // + // Skip the identification field because we don't need it. + // + + reader.Position += idLength; + + if (header.pixelDepth == 32) + header.hasAlpha = ((header.imageDescriptor & 0x0f) == 8); + else if (header.pixelDepth == 16) + header.hasAlpha = ((header.imageDescriptor & 0x0f) == 1); + else + header.hasAlpha = false; + + header.xFlip = ((header.imageDescriptor & 16) == 16); + header.yFlip = ((header.imageDescriptor & 32) == 32); + + return header; + } + + public static TgaHeader Create(int width, int height, TgaImageType imageType) + { + return new TgaHeader { + imageType = imageType, + width = width, + height = height, + pixelDepth = 32, + imageDescriptor = 8 + }; + } + + public void Write(BinaryWriter writer) + { + writer.Write((byte)0); + writer.Write((byte)(hasColorMap ? 1 : 0)); + writer.Write((byte)imageType); + writer.Write((ushort)colorMapIndex); + writer.Write((ushort)colorMapLength); + writer.Write((byte)colorMapEntrySize); + writer.Write((ushort)0); + writer.Write((ushort)0); + writer.Write((ushort)width); + writer.Write((ushort)height); + writer.Write((byte)pixelDepth); + writer.Write((byte)imageDescriptor); + } + + public SurfaceFormat GetSurfaceFormat() + { + switch (pixelDepth) + { + case 16: + return hasAlpha ? SurfaceFormat.BGRA5551 : SurfaceFormat.BGRX5551; + case 24: + return SurfaceFormat.BGRX; + default: + case 32: + return hasAlpha ? SurfaceFormat.BGRA : SurfaceFormat.BGRX; + } + } + + public Color GetPixel(byte[] src, int srcOffset) + { + switch (pixelDepth) + { + case 16: + if (hasAlpha) + return Color.ReadBgra5551(src, srcOffset); + else + return Color.ReadBgrx5551(src, srcOffset); + + case 24: + return Color.ReadBgrx(src, srcOffset); + + default: + case 32: + if (hasAlpha) + return Color.ReadBgra(src, srcOffset); + else + return Color.ReadBgrx(src, srcOffset); + } + } + } +} Index: /OniSplit/Imaging/TgaImageType.cs =================================================================== --- /OniSplit/Imaging/TgaImageType.cs (revision 1114) +++ /OniSplit/Imaging/TgaImageType.cs (revision 1114) @@ -0,0 +1,13 @@ +namespace Oni.Imaging +{ + internal enum TgaImageType : byte + { + None = 0, + ColorMapped = 1, + TrueColor = 2, + BlackAndWhite = 3, + RleColorMapped = 9, + RleTrueColor = 10, + RleBlackAndWhite = 11, + } +} Index: /OniSplit/Imaging/TgaReader.cs =================================================================== --- /OniSplit/Imaging/TgaReader.cs (revision 1114) +++ /OniSplit/Imaging/TgaReader.cs (revision 1114) @@ -0,0 +1,104 @@ +using System; + +namespace Oni.Imaging +{ + internal static class TgaReader + { + public static Surface Read(string filePath) + { + using (var reader = new BinaryReader(filePath)) + { + var header = TgaHeader.Read(reader); + + Surface surface; + + switch (header.ImageType) + { + case TgaImageType.TrueColor: + surface = LoadTrueColor(header, reader); + break; + + case TgaImageType.RleTrueColor: + surface = LoadRleTrueColor(header, reader); + break; + + default: + throw new NotSupportedException(string.Format("Invalid or unsupported TGA image type {0}", header.ImageType)); + } + + if (header.XFlip) + surface.FlipHorizontal(); + + if (!header.YFlip) + surface.FlipVertical(); + + return surface; + } + } + + private static Surface LoadTrueColor(TgaHeader header, BinaryReader reader) + { + int pixelSize = header.PixelSize; + var format = header.GetSurfaceFormat(); + + var dst = new Surface(header.Width, header.Height, format); + var src = reader.ReadBytes(header.Width * header.Height * pixelSize); + int srcOffset = 0; + + for (int y = 0; y < header.Height; y++) + { + for (int x = 0; x < header.Width; x++) + { + dst[x, y] = header.GetPixel(src, srcOffset); + srcOffset += pixelSize; + } + } + + return dst; + } + + private static Surface LoadRleTrueColor(TgaHeader header, BinaryReader reader) + { + int pixelSize = header.PixelSize; + var format = header.GetSurfaceFormat(); + + var dst = new Surface(header.Width, header.Height, format); + + var src = reader.ReadBytes(reader.Length - reader.Position); + int srcOffset = 0; + + int y = 0; + int x = 0; + + var color = Color.Black; + + while (y < header.Height) + { + int packetType = src[srcOffset++]; + + int packetPixelCount = (packetType & 127) + 1; + bool isRle = ((packetType & 128) != 0); + + for (int i = 0; i < packetPixelCount && y < header.Height; i++) + { + if (i == 0 || !isRle) + { + color = header.GetPixel(src, srcOffset); + srcOffset += pixelSize; + } + + dst[x, y] = color; + x++; + + if (x == header.Width) + { + x = 0; + y++; + } + } + } + + return dst; + } + } +} Index: /OniSplit/Imaging/TgaWriter.cs =================================================================== --- /OniSplit/Imaging/TgaWriter.cs (revision 1114) +++ /OniSplit/Imaging/TgaWriter.cs (revision 1114) @@ -0,0 +1,133 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Oni.Imaging +{ + internal static class TgaWriter + { + public static void Write(Surface surface, string filePath) + { + surface = surface.Convert(SurfaceFormat.BGRA); + + var imageType = TgaImageType.TrueColor; + byte[] rleData = null; + + if (surface.Width > 2 && surface.Height > 2) + { + rleData = Rle32Compress(surface.Width, surface.Height, surface.Data); + + if (rleData.Length > surface.Data.Length) + rleData = null; + else + imageType = TgaImageType.RleTrueColor; + } + + var header = TgaHeader.Create(surface.Width, surface.Height, imageType); + + Directory.CreateDirectory(Path.GetDirectoryName(filePath)); + + using (var stream = File.Create(filePath)) + using (var writer = new BinaryWriter(stream)) + { + header.Write(writer); + + if (rleData != null) + writer.Write(rleData, 0, rleData.Length); + else + writer.Write(surface.Data, 0, surface.Data.Length); + } + } + + private static byte[] Rle32Compress(int width, int height, byte[] sourceData) + { + var result = new List(); + + for (int y = height - 1; y >= 0; y--) + { + int lineOffset = y * width * 4; + int lastPixel = BitConverter.ToInt32(sourceData, y * width * 4); + int runStart = 0; + byte packetType = 64; + + for (int x = 1; x < width; x++) + { + int pixel = BitConverter.ToInt32(sourceData, x * 4 + lineOffset); + + if (pixel == lastPixel) + { + if (packetType == 0) + { + Rle32WritePackets(result, packetType, sourceData, runStart, x - 1, lineOffset); + runStart = x - 1; + } + + packetType = 128; + } + else + { + if (packetType == 128) + { + Rle32WritePackets(result, packetType, sourceData, runStart, x, lineOffset); + runStart = x; + } + + packetType = 0; + } + + lastPixel = pixel; + + if (x == width - 1) + { + Rle32WritePackets(result, packetType, sourceData, runStart, width, lineOffset); + } + } + } + + return result.ToArray(); + } + + private static void Rle32WritePackets(List result, byte packetType, byte[] sourceData, int xStart, int xStop, int lineOffset) + { + int count = xStop - xStart; + + if (count == 0) + return; + + int startOffset = (xStart * 4) + lineOffset; + + if (packetType == 128) + { + for (; count > 128; count -= 128) + { + result.Add((byte)(packetType | 127)); + + for (int i = 0; i < 4; i++) + result.Add(sourceData[startOffset + i]); + } + + result.Add((byte)(packetType | (count - 1))); + + for (int i = 0; i < 4; i++) + result.Add(sourceData[startOffset + i]); + } + else + { + for (; count > 128; count -= 128) + { + result.Add((byte)(packetType | 127)); + + for (int i = 0; i < 4 * 128; i++) + result.Add(sourceData[startOffset + i]); + + startOffset += 4 * 128; + } + + result.Add((byte)(packetType | (count - 1))); + + for (int i = 0; i < 4 * count; i++) + result.Add(sourceData[startOffset + i]); + } + } + } +} Index: /OniSplit/Importer.cs =================================================================== --- /OniSplit/Importer.cs (revision 1114) +++ /OniSplit/Importer.cs (revision 1114) @@ -0,0 +1,127 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Text; + +namespace Oni +{ + internal abstract class Importer + { + private readonly ImporterFile file; + private Dictionary dependencies; + + public Importer() + { + this.file = new ImporterFile(); + } + + protected Importer(long templateChecksum) + { + this.file = new ImporterFile(templateChecksum); + } + + public ImporterFile ImporterFile => file; + + public virtual void Import(string filePath, string outputDirPath) + { + } + + public virtual void BeginImport() + { + file.BeginImport(); + + dependencies = new Dictionary(); + } + + public BinaryWriter RawWriter => file.RawWriter; + + public void AddDependency(string filePath, TemplateTag type) + { + if (!dependencies.ContainsKey(filePath)) + dependencies[filePath] = new ImporterTask(filePath, type); + } + + public ICollection Dependencies + { + get + { + if (dependencies == null) + return new ImporterTask[0]; + + return dependencies.Values; + } + } + + public ImporterDescriptor CreateInstance(TemplateTag tag, string name = null) => file.CreateInstance(tag, name); + + public int WriteRawPart(byte[] data) => file.WriteRawPart(data); + + public int WriteRawPart(string text) => file.WriteRawPart(text); + + public void Write(string outputDirPath) => file.Write(outputDirPath); + + protected static string MakeInstanceName(TemplateTag tag, string name) + { + string tagName = tag.ToString(); + + if (!name.StartsWith(tagName, StringComparison.Ordinal)) + name = tagName + name; + + return name; + } + + public static string EncodeFileName(string name, Dictionary fileNames = null) + { + foreach (char c in Path.GetInvalidFileNameChars()) + name = name.Replace(c.ToString(), string.Format(CultureInfo.InvariantCulture, "%{0:X2}", (int)c)); + + if (fileNames != null) + { + string existingName; + + while (fileNames.TryGetValue(name, out existingName)) + { + int i = 0; + + if (name.Length > 4) + i = 4; + + while (i < name.Length && char.ToLowerInvariant(name[i]) != char.ToLowerInvariant(existingName[i])) + i++; + + name = name.Substring(0, i) + string.Format(CultureInfo.InvariantCulture, "%{0:X2}", (int)name[i]) + name.Substring(i + 1); + } + + fileNames[name] = name; + } + + return name; + } + + public static string DecodeFileName(string fileName) + { + fileName = Path.GetFileNameWithoutExtension(fileName); + + var buffer = new StringBuilder(); + + for (int i, startIndex = 0; startIndex != -1; startIndex = i) + { + i = fileName.IndexOf('%', startIndex); + + if (i == -1) + { + buffer.Append(fileName, startIndex, fileName.Length - startIndex); + } + else + { + buffer.Append(fileName, startIndex, i - startIndex); + buffer.Append((char)Int32.Parse(fileName.Substring(i + 1, 2), NumberStyles.HexNumber)); + i += 3; + } + } + + return buffer.ToString(); + } + } +} Index: /OniSplit/ImporterDescriptor.cs =================================================================== --- /OniSplit/ImporterDescriptor.cs (revision 1114) +++ /OniSplit/ImporterDescriptor.cs (revision 1114) @@ -0,0 +1,26 @@ +namespace Oni +{ + internal abstract class ImporterDescriptor + { + private readonly ImporterFile file; + private readonly TemplateTag tag; + private readonly int index; + private readonly string name; + + protected ImporterDescriptor(ImporterFile file, TemplateTag tag, int index, string name) + { + this.file = file; + this.tag = tag; + this.index = index; + this.name = name; + } + + public ImporterFile File => file; + public TemplateTag Tag => tag; + public int Index => index; + public string Name => name; + + public abstract BinaryWriter OpenWrite(); + public abstract BinaryWriter OpenWrite(int offset); + } +} Index: /OniSplit/ImporterDescriptorExtensions.cs =================================================================== --- /OniSplit/ImporterDescriptorExtensions.cs (revision 1114) +++ /OniSplit/ImporterDescriptorExtensions.cs (revision 1114) @@ -0,0 +1,58 @@ +using System; +using System.Collections.Generic; + +namespace Oni +{ + internal static class ImporterDescriptorExtensions + { + public static void WriteIndices(this ImporterDescriptor descriptor, int[] indices) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(indices.Length); + writer.Write(indices); + } + } + + public static void WritePoints(this ImporterDescriptor descriptor, ICollection points) + { + var bbox = BoundingBox.CreateFromPoints(points); + var bsphere = BoundingSphere.CreateFromPoints(points); + + using (var writer = descriptor.OpenWrite(12)) + { + writer.Write(bbox); + writer.Write(bsphere); + writer.Write(points.Count); + writer.Write(points); + } + } + + public static void WriteTexCoords(this ImporterDescriptor descriptor, ICollection texCoords) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(texCoords.Count); + writer.Write(texCoords); + } + } + + public static void WriteVectors(this ImporterDescriptor descriptor, ICollection vectors) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(vectors.Count); + writer.Write(vectors); + } + } + + public static void WritePlanes(this ImporterDescriptor descriptor, ICollection planes) + { + using (var writer = descriptor.OpenWrite(20)) + { + writer.Write(planes.Count); + writer.Write(planes); + } + } + } +} Index: /OniSplit/ImporterFile.cs =================================================================== --- /OniSplit/ImporterFile.cs (revision 1114) +++ /OniSplit/ImporterFile.cs (revision 1114) @@ -0,0 +1,307 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; + +namespace Oni +{ + internal sealed class ImporterFile + { + private static readonly byte[] txcaPadding = new byte[480]; + private readonly long templateChecksum = InstanceFileHeader.OniPCTemplateChecksum; + private MemoryStream rawStream; + private BinaryWriter rawWriter; + private List descriptors; + private int nameOffset; + + #region private class FileHeader + + private class FileHeader + { + public const int Size = 64; + + public long TemplateChecksum; + public int Version; + public int InstanceCount; + public int DataTableOffset; + public int DataTableSize; + public int NameTableOffset; + public int NameTableSize; + public int RawTableOffset; + public int RawTableSize; + + public void Write(BinaryWriter writer) + { + writer.Write(TemplateChecksum); + writer.Write(Version); + writer.Write(InstanceFileHeader.Signature); + writer.Write(InstanceCount); + writer.Write(0ul); + writer.Write(DataTableOffset); + writer.Write(DataTableSize); + writer.Write(NameTableOffset); + writer.Write(NameTableSize); + writer.Write(RawTableOffset); + writer.Write(RawTableSize); + writer.Write(0ul); + } + } + + #endregion + + public ImporterFile() + { + } + + public ImporterFile(long templateChecksum) + { + this.templateChecksum = templateChecksum; + } + + public void BeginImport() + { + rawStream = null; + rawWriter = null; + + descriptors = new List(); + nameOffset = 0; + } + + public BinaryWriter RawWriter + { + get + { + if (rawWriter == null) + { + rawStream = new MemoryStream(); + rawWriter = new BinaryWriter(rawStream); + rawWriter.Write(new byte[32]); + } + + return rawWriter; + } + } + + public ImporterDescriptor CreateInstance(TemplateTag tag, string name = null) + { + var descriptor = new ImporterFileDescriptor(this, tag, descriptors.Count, MakeInstanceName(tag, name)); + + descriptors.Add(descriptor); + + return descriptor; + } + + public int WriteRawPart(byte[] data) + { + int offset = RawWriter.Align32(); + RawWriter.Write(data); + return offset; + } + + public int WriteRawPart(string text) + { + return WriteRawPart(Encoding.UTF8.GetBytes(text)); + } + + private sealed class ImporterFileDescriptor : ImporterDescriptor + { + public const int Size = 20; + + private int nameOffset; + private int dataOffset; + private byte[] data; + + public ImporterFileDescriptor(ImporterFile file, TemplateTag tag, int index, string name) + : base(file, tag, index, name) + { + if (!string.IsNullOrEmpty(name)) + { + nameOffset = file.nameOffset; + file.nameOffset += name.Length + 1; + } + } + + public int NameOffset + { + get { return nameOffset; } + set { nameOffset = value; } + } + + public int DataOffset + { + get { return dataOffset; } + set { dataOffset = value; } + } + + public int DataSize + { + get + { + if (data == null) + return 0; + + return data.Length + 8; + } + } + + public byte[] Data + { + get { return data; } + } + + public override BinaryWriter OpenWrite() + { + if (data != null) + throw new InvalidOperationException("Descriptor has already been written to"); + + return new InstanceWriter(this); + } + + public override BinaryWriter OpenWrite(int offset) + { + if (data != null) + throw new InvalidOperationException("Descriptor has already been written to"); + + var writer = new InstanceWriter(this); + writer.Skip(offset); + return writer; + } + + public void Close(byte[] data) + { + this.data = data; + } + } + + private class InstanceWriter : BinaryWriter + { + private readonly ImporterFileDescriptor descriptor; + + public InstanceWriter(ImporterFileDescriptor descriptor) + : base(new MemoryStream()) + { + this.descriptor = descriptor; + } + + protected override void Dispose(bool disposing) + { + var stream = (MemoryStream)BaseStream; + + if (descriptor.Tag == TemplateTag.TXCA) + stream.Write(txcaPadding, 0, txcaPadding.Length); + else if (stream.Position > stream.Length) + stream.SetLength(stream.Position); + + descriptor.Close(stream.ToArray()); + + base.Dispose(disposing); + } + } + + public void Write(string outputDirPath) + { + var filePath = Path.Combine(outputDirPath, Importer.EncodeFileName(descriptors[0].Name) + ".oni"); + + Directory.CreateDirectory(outputDirPath); + + int nameTableOffset = Utils.Align32(FileHeader.Size + ImporterFileDescriptor.Size * descriptors.Count); + int nameTableSize = nameOffset; + int dataTableOffset = Utils.Align32(nameTableOffset + nameOffset); + int dataTableSize = 0; + + foreach (var descriptor in descriptors.Where(d => d.Data != null)) + { + descriptor.DataOffset = dataTableSize + 8; + + dataTableSize += Utils.Align32(descriptor.DataSize); + } + + var header = new FileHeader + { + TemplateChecksum = templateChecksum, + Version = InstanceFileHeader.Version32, + InstanceCount = descriptors.Count, + DataTableOffset = dataTableOffset, + DataTableSize = dataTableSize, + NameTableOffset = nameTableOffset, + NameTableSize = nameTableSize + }; + + using (var stream = File.Create(filePath)) + using (var writer = new BinaryWriter(stream)) + { + bool hasRawParts = (rawStream != null && rawStream.Length > 32); + + if (hasRawParts) + { + header.RawTableOffset = Utils.Align32(header.DataTableOffset + header.DataTableSize); + header.RawTableSize = (int)rawStream.Length; + } + + header.Write(writer); + + foreach (var descriptor in descriptors) + { + WriteDescriptor(writer, descriptor); + } + + writer.Position = header.NameTableOffset; + + foreach (var entry in descriptors) + { + if (entry.Name != null) + writer.Write(entry.Name, entry.Name.Length + 1); + } + + writer.Position = header.DataTableOffset; + + foreach (var descriptor in descriptors.Where(d => d.Data != null)) + { + writer.Align32(); + writer.WriteInstanceId(descriptor.Index); + writer.Write(0); + writer.Write(descriptor.Data); + } + + if (hasRawParts) + { + writer.Position = header.RawTableOffset; + rawStream.WriteTo(stream); + } + } + } + + private void WriteDescriptor(BinaryWriter writer, ImporterFileDescriptor descriptor) + { + var flags = InstanceDescriptorFlags.None; + + if (descriptor.Name == null) + flags |= InstanceDescriptorFlags.Private; + + if (descriptor.Data == null) + flags |= InstanceDescriptorFlags.Placeholder; + + if (descriptor.Name == null && descriptor.Data == null) + throw new InvalidOperationException("Link descriptors must have names"); + + writer.Write((int)descriptor.Tag); + writer.Write(descriptor.DataOffset); + writer.Write(descriptor.NameOffset); + writer.Write(descriptor.DataSize); + writer.Write((int)flags); + } + + private static string MakeInstanceName(TemplateTag tag, string name) + { + if (string.IsNullOrEmpty(name)) + return null; + + var tagName = tag.ToString(); + + if (!name.StartsWith(tagName, StringComparison.Ordinal)) + name = tagName + name; + + return name; + } + } +} Index: /OniSplit/ImporterTask.cs =================================================================== --- /OniSplit/ImporterTask.cs (revision 1114) +++ /OniSplit/ImporterTask.cs (revision 1114) @@ -0,0 +1,22 @@ +namespace Oni +{ + internal struct ImporterTask + { + private readonly string filePath; + private readonly TemplateTag type; + + public ImporterTask(string filePath) + : this(filePath, TemplateTag.NONE) + { + } + + public ImporterTask(string filePath, TemplateTag type) + { + this.filePath = filePath; + this.type = type; + } + + public string FilePath => filePath; + public TemplateTag Type => type; + } +} Index: /OniSplit/InstanceDescriptor.cs =================================================================== --- /OniSplit/InstanceDescriptor.cs (revision 1114) +++ /OniSplit/InstanceDescriptor.cs (revision 1114) @@ -0,0 +1,166 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Oni.Metadata; + +namespace Oni +{ + internal sealed class InstanceDescriptor + { + private InstanceFile file; + private string fullName; + private int index; + private Template template; + private int dataOffset; + private int nameOffset; + private int dataSize; + private InstanceDescriptorFlags flags; + + internal static InstanceDescriptor Read(InstanceFile file, BinaryReader reader, int index) + { + var metadata = InstanceMetadata.GetMetadata(file); + + var descriptor = new InstanceDescriptor + { + file = file, + index = index, + template = metadata.GetTemplate((TemplateTag)reader.ReadInt32()), + dataOffset = reader.ReadInt32(), + nameOffset = reader.ReadInt32(), + dataSize = reader.ReadInt32(), + flags = (InstanceDescriptorFlags)(reader.ReadInt32() & 0xff) + }; + + if (descriptor.IsPlaceholder && !descriptor.HasName) + throw new InvalidDataException("Empty descriptors must have names"); + + return descriptor; + } + + public InstanceFile File => file; + + public int Index => index; + + public string FullName + { + get + { + if (fullName == null) + fullName = index.ToString(); + + return fullName; + } + } + + public string Name + { + get + { + string name = FullName; + + if (name.StartsWith(Template.Tag.ToString(), StringComparison.Ordinal)) + name = name.Substring(4); + + return name; + } + } + + public Template Template => template; + + public bool HasName => ((flags & InstanceDescriptorFlags.Private) == 0); + + public bool IsPlaceholder => ((flags & InstanceDescriptorFlags.Placeholder) != 0 || dataSize == 0 || dataOffset == 0); + + public int DataOffset => file.Header.DataTableOffset + dataOffset; + + public int DataSize => dataSize; + + internal void ReadName(Dictionary names) + { + if (!HasName) + return; + + if (IsPlaceholder || file.Header.Version == InstanceFileHeader.Version31) + { + names.TryGetValue(nameOffset, out fullName); + } + else + { + fullName = Importer.DecodeFileName(file.FilePath); + + string tagName = template.Tag.ToString(); + + if (!fullName.StartsWith(tagName, StringComparison.Ordinal)) + fullName = tagName + fullName; + } + } + + internal void SetName(string newName) + { + flags &= ~InstanceDescriptorFlags.Private; + fullName = newName; + } + + public List GetReferencedDescriptors() => file.GetReferencedDescriptors(this); + + internal BinaryReader OpenRead() + { + if (IsPlaceholder) + throw new InvalidOperationException(); + + return new BinaryReader(file.FilePath, file) + { + Position = DataOffset + }; + } + + internal BinaryReader OpenRead(int offset) + { + if (IsPlaceholder) + throw new InvalidOperationException(); + + return new BinaryReader(file.FilePath, file) + { + Position = DataOffset + offset + }; + } + + internal BinaryReader GetRawReader(int offset) => file.GetRawReader(offset); + + internal BinaryReader GetSepReader(int offset) + { + if (!IsMacFile) + return GetRawReader(offset); + + return file.GetSepReader(offset); + } + + internal bool IsMacFile => (file.Header.TemplateChecksum == InstanceFileHeader.OniMacTemplateChecksum); + + public long TemplateChecksum => file.Header.TemplateChecksum; + + public string FilePath => file.FilePath; + + public bool HasRawParts() + { + if (IsPlaceholder) + return false; + + switch (template.Tag) + { + case TemplateTag.AKVA: + case TemplateTag.AGDB: + case TemplateTag.BINA: + case TemplateTag.TXMP: + case TemplateTag.OSBD: + case TemplateTag.SNDD: + case TemplateTag.SUBT: + case TemplateTag.TRAM: + return true; + + default: + return false; + } + } + } +} Index: /OniSplit/InstanceDescriptorFlags.cs =================================================================== --- /OniSplit/InstanceDescriptorFlags.cs (revision 1114) +++ /OniSplit/InstanceDescriptorFlags.cs (revision 1114) @@ -0,0 +1,13 @@ +using System; + +namespace Oni +{ + [Flags] + internal enum InstanceDescriptorFlags + { + None = 0x0000, + Private = 0x0001, + Placeholder = 0x0002, + Shared = 0x0008 + } +} Index: /OniSplit/InstanceFile.cs =================================================================== --- /OniSplit/InstanceFile.cs (revision 1114) +++ /OniSplit/InstanceFile.cs (revision 1114) @@ -0,0 +1,291 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Oni.Metadata; + +namespace Oni +{ + internal sealed class InstanceFile + { + private readonly InstanceFileManager fileManager; + private readonly string filePath; + private InstanceFileHeader header; + private Dictionary rawParts; + private Dictionary sepParts; + private string rawFilePath; + private string sepFilePath; + private List descriptors; + private IList readOnlyDescriptors; + + private InstanceFile(InstanceFileManager fileManager, string filePath) + { + this.fileManager = fileManager; + this.filePath = filePath; + } + + public static InstanceFile Read(InstanceFileManager fileManager, string filePath) + { + var file = new InstanceFile(fileManager, filePath); + + using (var reader = new BinaryReader(filePath)) + { + var header = InstanceFileHeader.Read(reader); + var descriptors = new List(header.InstanceCount); + + file.header = header; + file.descriptors = descriptors; + + for (int i = 0; i < file.header.InstanceCount; i++) + descriptors.Add(InstanceDescriptor.Read(file, reader, i)); + + var names = ReadNames(header, reader); + + for (int i = 0; i < file.header.InstanceCount; i++) + descriptors[i].ReadName(names); + } + + // + // Force AGDB instances to have a name so they get exported into separate .oni files + // instead of being exported inside an AKEV.oni file. This code assumes that there + // is only 1 AGDB/AKEV file per .dat file (or none at all). + // + + foreach (var descriptor in file.descriptors) + { + if (descriptor.Template.Tag != TemplateTag.AGDB) + continue; + + var akevDescriptors = file.GetNamedDescriptors(TemplateTag.AKEV); + + if (akevDescriptors.Count == 1) + { + string agdbName = "AGDB" + akevDescriptors[0].Name; + descriptor.SetName(agdbName); + break; + } + } + + return file; + } + + private static Dictionary ReadNames(InstanceFileHeader header, BinaryReader reader) + { + reader.Position = header.NameTableOffset; + + var nameTable = reader.ReadBytes(header.NameTableSize); + int nameOffset = 0; + + var names = new Dictionary(header.NameCount); + var buffer = new char[64]; + + while (nameOffset < nameTable.Length) + { + int i = 0; + + while (true) + { + byte c = nameTable[nameOffset + i]; + + if (c == 0) + break; + + buffer[i++] = (char)c; + } + + names.Add(nameOffset, new string(buffer, 0, i)); + nameOffset += i + 1; + } + + return names; + } + + public InstanceFileManager FileManager + { + get { return fileManager; } + } + + public string FilePath + { + get { return filePath; } + } + + public InstanceFileHeader Header + { + get { return header; } + } + + public List GetReferencedDescriptors(InstanceDescriptor descriptor) + { + var result = new List(); + + result.Add(descriptor); + + var stack = new Stack(); + var seen = new bool[descriptors.Count]; + + stack.Push(descriptor); + seen[descriptor.Index] = true; + + using (var reader = new BinaryReader(filePath)) + { + var linkVisitor = new LinkVisitor(reader); + + while (stack.Count > 0) + { + descriptor = stack.Pop(); + reader.Position = descriptor.DataOffset; + linkVisitor.Links.Clear(); + + descriptor.Template.Type.Accept(linkVisitor); + + foreach (int id in linkVisitor.Links) + { + if (!seen[id >> 8]) + { + var referencedDescriptor = GetDescriptor(id); + + if (!referencedDescriptor.IsPlaceholder && !referencedDescriptor.HasName) + stack.Push(referencedDescriptor); + + result.Add(referencedDescriptor); + seen[referencedDescriptor.Index] = true; + } + } + } + } + + return result; + } + + public int GetRawPartSize(int offset) + { + EnsureRawAndSepParts(); + return rawParts[offset]; + } + + public int GetSepPartSize(int offset) + { + EnsureRawAndSepParts(); + return sepParts[offset]; + } + + public string RawFilePath + { + get + { + if (rawFilePath == null) + { + if (header.Version == InstanceFileHeader.Version31) + rawFilePath = Path.ChangeExtension(filePath, ".raw"); + else + rawFilePath = filePath; + } + + return rawFilePath; + } + } + + public string SepFilePath + { + get + { + if (sepFilePath == null) + sepFilePath = Path.ChangeExtension(filePath, ".sep"); + + return sepFilePath; + } + } + + public BinaryReader GetRawReader(int offset) + { + return GetBinaryReader(offset, RawFilePath); + } + + public BinaryReader GetSepReader(int offset) + { + return GetBinaryReader(offset, SepFilePath); + } + + private void EnsureRawAndSepParts() + { + if (rawParts != null) + return; + + rawParts = new Dictionary(); + sepParts = new Dictionary(); + + InstanceMetadata.GetRawAndSepParts(this, rawParts, sepParts); + } + + private BinaryReader GetBinaryReader(int offset, string binaryFilePath) + { + var reader = new BinaryReader(binaryFilePath); + reader.Position = offset + header.RawTableOffset; + return reader; + } + + public InstanceDescriptor ResolveLink(int id) + { + var descriptor = GetDescriptor(id); + + if (descriptor == null || !descriptor.IsPlaceholder) + return descriptor; + + if (!descriptor.HasName) + return null; + + var file = fileManager.FindInstance(descriptor.FullName, this); + + if (file == null || file == this) + { + Console.Error.WriteLine("Cannot find instance '{0}'", descriptor.FullName); + return null; + } + + if (file.header.Version == InstanceFileHeader.Version32) + return file.GetDescriptor(1); + + foreach (var target in file.descriptors) + { + if (target.HasName && target.FullName == descriptor.FullName) + return target; + } + + return null; + } + + public InstanceDescriptor GetDescriptor(int id) + { + if (id == 0) + return null; + + return descriptors[id >> 8]; + } + + public IList Descriptors + { + get + { + if (readOnlyDescriptors == null) + readOnlyDescriptors = descriptors.AsReadOnly(); + + return readOnlyDescriptors; + } + } + + public List GetNamedDescriptors() + { + return descriptors.FindAll(x => x.HasName && !x.IsPlaceholder); + } + + public List GetNamedDescriptors(TemplateTag tag) + { + return descriptors.FindAll(x => x.Template.Tag == tag && x.HasName && !x.IsPlaceholder); + } + + public List GetPlaceholders() + { + return descriptors.FindAll(x => x.HasName && x.IsPlaceholder); + } + } +} Index: /OniSplit/InstanceFileHeader.cs =================================================================== --- /OniSplit/InstanceFileHeader.cs (revision 1114) +++ /OniSplit/InstanceFileHeader.cs (revision 1114) @@ -0,0 +1,90 @@ +using System; +using System.IO; + +namespace Oni +{ + internal sealed class InstanceFileHeader + { + public const long OniPCTemplateChecksum = 0x0003bcdf33dc271f; + public const long OniMacTemplateChecksum = 0x0003bcdf23c13061; + public const int Version31 = 0x56523331; + public const int Version32 = 0x56523332; + public const long Signature = 0x0008001000140040; + + #region Private data + private long templateChecksum; + private int version; + private long signature; + private int instanceCount; + private int nameCount; + private int templateCount; + private int dataTableOffset; + private int dataTableSize; + private int nameTableOffset; + private int nameTableSize; + private int rawTableOffset; + private int rawTableSize; + #endregion + + internal static InstanceFileHeader Read(BinaryReader reader) + { + var header = new InstanceFileHeader + { + templateChecksum = reader.ReadInt64(), + version = reader.ReadInt32(), + signature = reader.ReadInt64() + }; + + ValidateHeader(header); + + header.instanceCount = reader.ReadInt32(); + header.nameCount = reader.ReadInt32(); + header.templateCount = reader.ReadInt32(); + header.dataTableOffset = reader.ReadInt32(); + header.dataTableSize = reader.ReadInt32(); + header.nameTableOffset = reader.ReadInt32(); + header.nameTableSize = reader.ReadInt32(); + + if (header.version == Version32) + { + header.rawTableOffset = reader.ReadInt32(); + header.rawTableSize = reader.ReadInt32(); + + reader.Skip(8); + } + else + { + reader.Skip(16); + } + + return header; + } + + private static void ValidateHeader(InstanceFileHeader header) + { + if (header.templateChecksum != OniPCTemplateChecksum && header.templateChecksum != OniMacTemplateChecksum) + { + header.templateChecksum = OniMacTemplateChecksum; + //throw new InvalidDataException("Invalid template checksum"); + } + + if (header.version != Version31 && header.version != Version32) + throw new InvalidDataException("Unknown file version"); + + if (header.version == Version31 && header.signature != Signature) + throw new InvalidDataException("Invalid file signature"); + } + + public long TemplateChecksum => templateChecksum; + public int Version => version; + public int InstanceCount => instanceCount; + public int NameCount => nameCount; + public int TemplateCoun => templateCount; + public int DataTableOffset => dataTableOffset; + public int DataTableSize => dataTableSize; + public int NameTableOffset => nameTableOffset; + public int NameTableSize => nameTableSize; + public int RawTableOffset => rawTableOffset; + public int RawTableSize => rawTableSize; + } +} Index: /OniSplit/InstanceFileManager.cs =================================================================== --- /OniSplit/InstanceFileManager.cs (revision 1114) +++ /OniSplit/InstanceFileManager.cs (revision 1114) @@ -0,0 +1,196 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Oni.Collections; + +namespace Oni +{ + internal sealed class InstanceFileManager + { + private readonly List searchPaths = new List(); + private readonly Dictionary loadedFiles = new Dictionary(StringComparer.OrdinalIgnoreCase); + private Dictionary files; + + public InstanceFile OpenFile(string filePath) + { + InstanceFile file; + + if (!loadedFiles.TryGetValue(filePath, out file)) + { + try + { + file = InstanceFile.Read(this, filePath); + } + catch (Exception ex) + { + Console.Error.WriteLine("Error opening file {0}: {1}", filePath, ex.Message); + throw; + } + + loadedFiles.Add(filePath, file); + } + + return file; + } + + public List OpenDirectories(string[] dirPaths) + { + var files = new List(); + var seenFileNames = new Set(StringComparer.Ordinal); + + Array.Reverse(dirPaths); + + foreach (string dirPath in dirPaths) + { + var filePaths = FindFiles(dirPath); + + foreach (string filePath in filePaths) + { + if (!seenFileNames.Contains(Path.GetFileName(filePath))) + files.Add(OpenFile(filePath)); + } + + foreach (string filePath in filePaths) + seenFileNames.Add(Path.GetFileName(filePath)); + } + + return files; + } + + public List OpenDirectory(string dirPath) + { + var files = new List(); + + foreach (string filePath in FindFiles(dirPath)) + files.Add(OpenFile(filePath)); + + return files; + } + + public void AddSearchPath(string path) + { + if (Directory.Exists(path)) + searchPaths.Add(path); + } + + public InstanceFile FindInstance(string instanceName) + { + if (files == null) + { + files = new Dictionary(StringComparer.Ordinal); + + foreach (string searchPath in searchPaths) + { + foreach (string filePath in FindFiles(searchPath)) + { + string name = Importer.DecodeFileName(filePath); + + if (!files.ContainsKey(name)) + files[name] = filePath; + } + } + } + + string instanceFilePath; + + if (!files.TryGetValue(instanceName, out instanceFilePath)) + return null; + + var file = OpenFile(instanceFilePath); + + if (file == null) + return null; + + var descriptor = file.Descriptors[0]; + + if (file.Header.Version != InstanceFileHeader.Version32) + return null; + + if (descriptor == null || !descriptor.HasName || descriptor.FullName != instanceName) + return null; + + return file; + } + + public InstanceFile FindInstance(string instanceName, InstanceFile baseFile) + { + if (files == null) + { + files = new Dictionary(StringComparer.Ordinal); + + foreach (string filePath in FindFiles(Path.GetDirectoryName(baseFile.FilePath))) + files[Importer.DecodeFileName(filePath)] = filePath; + + foreach (string searchPath in searchPaths) + { + foreach (string filePath in FindFiles(searchPath)) + { + string name = Importer.DecodeFileName(filePath); + + if (!files.ContainsKey(name)) + files[name] = filePath; + } + } + } + + string instanceFilePath; + + if (!files.TryGetValue(instanceName, out instanceFilePath)) + { + if (instanceName.Length > 4) + instanceName = instanceName.Substring(4); + + if (!files.TryGetValue(instanceName, out instanceFilePath)) + { + string level0FilePath = Path.Combine(Path.GetDirectoryName(baseFile.FilePath), "level0_Final.dat"); + + if (!File.Exists(level0FilePath)) + return null; + + return OpenFile(level0FilePath); + } + } + + var file = OpenFile(instanceFilePath); + + if (file == null || file == baseFile) + return null; + + var descriptor = file.Descriptors[0]; + + if (file.Header.Version == InstanceFileHeader.Version32) + return file; + + if (descriptor == null || !descriptor.HasName || descriptor.FullName != instanceName) + return null; + + return file; + } + + private static List FindFiles(string dirPath) + { + var files = new List(); + + if (Directory.Exists(dirPath)) + FindFilesRecursive(dirPath, files); + + return files; + } + + private static void FindFilesRecursive(string dirPath, List files) + { + files.AddRange(Directory.GetFiles(dirPath, "*.oni")); + + foreach (string childDirPath in Directory.GetDirectories(dirPath)) + { + string name = Path.GetFileName(childDirPath); + + if (!string.Equals(name, "_noimport", StringComparison.OrdinalIgnoreCase) + && !string.Equals(name, "noimport", StringComparison.OrdinalIgnoreCase)) + { + FindFilesRecursive(childDirPath, files); + } + } + } + } +} Index: /OniSplit/InstanceFileOperations.cs =================================================================== --- /OniSplit/InstanceFileOperations.cs (revision 1114) +++ /OniSplit/InstanceFileOperations.cs (revision 1114) @@ -0,0 +1,174 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Oni +{ + internal sealed class InstanceFileOperations + { + private InstanceFileManager fileManager; + private string destinationDir; + private readonly Dictionary fileNames = new Dictionary(StringComparer.OrdinalIgnoreCase); + private Dictionary referencedFiles; + private readonly Dictionary instances = new Dictionary(StringComparer.Ordinal); + + public void Copy(InstanceFileManager fileManager, List sourceFiles, string destinationDir) + { + Initialize(fileManager, sourceFiles, destinationDir); + + foreach (KeyValuePair pair in referencedFiles) + { + if (File.Exists(pair.Value)) + { + if (!Utils.AreFilesEqual(pair.Key, pair.Value)) + Console.WriteLine("File {0} already exists at destination and it is different. File not copied.", pair.Value); + } + else + { + File.Copy(pair.Key, pair.Value); + } + } + } + + public void Move(InstanceFileManager fileManager, List sourceFilePaths, string outputDirPath) + { + Initialize(fileManager, sourceFilePaths, outputDirPath); + + foreach (KeyValuePair pair in referencedFiles) + { + if (File.Exists(pair.Value)) + { + if (Utils.AreFilesEqual(pair.Key, pair.Value)) + File.Delete(pair.Key); + else + Console.WriteLine("File {0} already exists at destination and it is different. Source file not moved.", pair.Value); + } + else + { + File.Move(pair.Key, pair.Value); + } + } + } + + public void MoveOverwrite(InstanceFileManager fileManager, List sourceFilePaths, string outputDirPath) + { + Initialize(fileManager, sourceFilePaths, outputDirPath); + + foreach (KeyValuePair pair in referencedFiles) + { + if (File.Exists(pair.Value)) + File.Delete(pair.Value); + + File.Move(pair.Key, pair.Value); + } + } + + public void MoveDelete(InstanceFileManager fileManager, List sourceFilePaths, string outputDirPath) + { + Initialize(fileManager, sourceFilePaths, outputDirPath); + + foreach (KeyValuePair pair in referencedFiles) + { + if (File.Exists(pair.Value)) + File.Delete(pair.Key); + else + File.Move(pair.Key, pair.Value); + } + } + + public void GetDependencies(InstanceFileManager fileManager, List sourceFilePaths) + { + Initialize(fileManager, sourceFilePaths, null); + + foreach (string filePath in referencedFiles.Keys) + { + Console.WriteLine(filePath); + } + } + + private void Initialize(InstanceFileManager fileManager, List inputFiles, string destinationDir) + { + this.fileManager = fileManager; + this.destinationDir = destinationDir; + this.referencedFiles = new Dictionary(StringComparer.OrdinalIgnoreCase); + + if (destinationDir != null) + { + if (Directory.Exists(destinationDir)) + { + // + // Get a list of existing files to avoid name conflicts due to instance names + // that differ only in case. + // + + foreach (string existingFilePath in Directory.GetFiles(destinationDir, "*.oni")) + { + string fileName = Path.GetFileNameWithoutExtension(existingFilePath); + string instanceName = Importer.DecodeFileName(existingFilePath); + + fileNames[fileName] = fileName; + instances[instanceName] = existingFilePath; + } + } + else + { + Directory.CreateDirectory(destinationDir); + } + } + + var sourceFiles = new Dictionary(StringComparer.Ordinal); + string lastSourceDir = null; + + foreach (string inputFile in inputFiles) + { + string sourceDir = Path.GetDirectoryName(inputFile); + + if (sourceDir != lastSourceDir) + { + lastSourceDir = sourceDir; + sourceFiles.Clear(); + + foreach (string file in Directory.GetFiles(sourceDir, "*.oni")) + sourceFiles[Importer.DecodeFileName(file)] = file; + } + + GetReferencedFiles(inputFile, sourceFiles); + } + } + + private void GetReferencedFiles(string sourceFile, Dictionary sourceFiles) + { + AddReferencedFile(sourceFile); + + var instanceFile = fileManager.OpenFile(sourceFile); + + foreach (var descriptor in instanceFile.GetPlaceholders()) + { + string referencedSourceFile; + + if (!sourceFiles.TryGetValue(descriptor.FullName, out referencedSourceFile) + || referencedFiles.ContainsKey(referencedSourceFile)) + continue; + + GetReferencedFiles(referencedSourceFile, sourceFiles); + } + } + + private void AddReferencedFile(string filePath) + { + if (referencedFiles.ContainsKey(filePath)) + return; + + string instanceName = Importer.DecodeFileName(filePath); + string destinationFile; + + if (!instances.TryGetValue(instanceName, out destinationFile)) + { + if (destinationDir != null) + destinationFile = Path.Combine(destinationDir, Importer.EncodeFileName(instanceName, fileNames) + ".oni"); + } + + referencedFiles.Add(filePath, destinationFile); + } + } +} Index: /OniSplit/InstanceFileWriter.cs =================================================================== --- /OniSplit/InstanceFileWriter.cs (revision 1114) +++ /OniSplit/InstanceFileWriter.cs (revision 1114) @@ -0,0 +1,1315 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Text; +using Oni.Collections; +using Oni.Metadata; + +namespace Oni +{ + internal sealed class InstanceFileWriter + { + #region Private data + private static readonly byte[] padding = new byte[512]; + private static byte[] copyBuffer1 = new byte[32768]; + private static byte[] copyBuffer2 = new byte[32768]; + private StreamCache streamCache; + private readonly bool bigEndian; + private readonly Dictionary namedInstancedIdMap; + private readonly FileHeader header; + private readonly List descriptorTable; + private NameDescriptorTable nameIndex; + private TemplateDescriptorTable templateTable; + private NameTable nameTable; + private readonly Dictionary sharedMap; + private readonly Dictionary linkMaps; + private readonly Dictionary> rawOffsetMaps; + private readonly Dictionary> sepOffsetMaps; + private int rawOffset; + private int sepOffset; + private List rawParts; + private List sepParts; + #endregion + + #region private class FileHeader + + private class FileHeader + { + public const int Size = 64; + + public long TemplateChecksum; + public int Version; + public int InstanceCount; + public int NameCount; + public int TemplateCount; + public int DataTableOffset; + public int DataTableSize; + public int NameTableOffset; + public int NameTableSize; + public int RawTableOffset; + public int RawTableSize; + + public void Write(BinaryWriter writer) + { + writer.Write(TemplateChecksum); + writer.Write(Version); + writer.Write(InstanceFileHeader.Signature); + writer.Write(InstanceCount); + writer.Write(NameCount); + writer.Write(TemplateCount); + writer.Write(DataTableOffset); + writer.Write(DataTableSize); + writer.Write(NameTableOffset); + writer.Write(NameTableSize); + writer.Write(RawTableOffset); + writer.Write(RawTableSize); + writer.Write(0); + writer.Write(0); + } + } + + #endregion + #region private class DescriptorTableEntry + + private class DescriptorTableEntry + { + public const int Size = 20; + + public readonly InstanceDescriptor SourceDescriptor; + public readonly int Id; + public int DataOffset; + public int NameOffset; + public int DataSize; + public bool AnimationPositionPointHack; + + public DescriptorTableEntry(int id, InstanceDescriptor descriptor) + { + Id = id; + SourceDescriptor = descriptor; + } + + public bool HasName => SourceDescriptor.HasName; + public string Name => SourceDescriptor.FullName; + public TemplateTag Code => SourceDescriptor.Template.Tag; + public InstanceFile SourceFile => SourceDescriptor.File; + + public void Write(BinaryWriter writer, bool shared) + { + writer.Write((int)Code); + writer.Write(DataOffset); + writer.Write(NameOffset); + writer.Write(DataSize); + + var flags = InstanceDescriptorFlags.None; + + if (!SourceDescriptor.HasName) + flags |= InstanceDescriptorFlags.Private; + + if (DataOffset == 0) + flags |= InstanceDescriptorFlags.Placeholder; + + if (shared) + flags |= InstanceDescriptorFlags.Shared; + + writer.Write((int)flags); + } + } + + #endregion + #region private class NameDescriptorTable + + private class NameDescriptorTable + { + private List entries; + + #region private class Entry + + private class Entry : IComparable + { + public const int Size = 8; + + public int InstanceNumber; + public string Name; + + public void Write(BinaryWriter writer) + { + writer.Write(InstanceNumber); + writer.Write(0); + } + + #region IComparable Members + + int IComparable.CompareTo(Entry other) + { + // + // Note: Oni is case sensitive so we need to sort names accordingly. + // + + return string.CompareOrdinal(Name, other.Name); + } + + #endregion + } + + #endregion + + public static NameDescriptorTable CreateFromDescriptors(List descriptorTable) + { + NameDescriptorTable nameIndex = new NameDescriptorTable(); + + nameIndex.entries = new List(); + + for (int i = 0; i < descriptorTable.Count; i++) + { + DescriptorTableEntry descriptor = descriptorTable[i]; + + if (descriptor.HasName) + { + Entry entry = new Entry(); + entry.Name = descriptor.Name; + entry.InstanceNumber = i; + nameIndex.entries.Add(entry); + } + } + + nameIndex.entries.Sort(); + + return nameIndex; + } + + public int Count => entries.Count; + public int Size => entries.Count * Entry.Size; + + public void Write(BinaryWriter writer) + { + foreach (Entry entry in entries) + entry.Write(writer); + } + } + + #endregion + #region private class TemplateDescriptorTable + + private class TemplateDescriptorTable + { + private List entries; + + #region private class Entry + + private class Entry : IComparable + { + public const int Size = 16; + + public long Checksum; + public TemplateTag Code; + public int Count; + + public void Write(BinaryWriter writer) + { + writer.Write(Checksum); + writer.Write((int)Code); + writer.Write(Count); + } + + int IComparable.CompareTo(Entry other) => Code.CompareTo(other.Code); + } + + #endregion + + public static TemplateDescriptorTable CreateFromDescriptors(InstanceMetadata metadata, List descriptorTable) + { + Dictionary templateCount = new Dictionary(); + + foreach (DescriptorTableEntry entry in descriptorTable) + { + int count; + templateCount.TryGetValue(entry.Code, out count); + templateCount[entry.Code] = count + 1; + } + + TemplateDescriptorTable templateTable = new TemplateDescriptorTable(); + templateTable.entries = new List(templateCount.Count); + + foreach (KeyValuePair pair in templateCount) + { + Entry entry = new Entry(); + entry.Checksum = metadata.GetTemplate(pair.Key).Checksum; + entry.Code = pair.Key; + entry.Count = pair.Value; + templateTable.entries.Add(entry); + } + + templateTable.entries.Sort(); + + return templateTable; + } + + public int Count => entries.Count; + + public int Size => entries.Count * Entry.Size; + + public void Write(BinaryWriter writer) + { + foreach (Entry entry in entries) + entry.Write(writer); + } + } + + #endregion + #region private class NameTable + + private class NameTable + { + private List names; + private int size; + + public static NameTable CreateFromDescriptors(List descriptors) + { + NameTable nameTable = new NameTable(); + + nameTable.names = new List(); + + int nameTableSize = 0; + + foreach (DescriptorTableEntry descriptor in descriptors) + { + if (!descriptor.HasName) + continue; + + string name = descriptor.Name; + + nameTable.names.Add(name); + descriptor.NameOffset = nameTableSize; + nameTableSize += name.Length + 1; + + if (name.Length > 63) + Console.WriteLine("Warning: name '{0}' too long.", name); + } + + nameTable.size = nameTableSize; + + return nameTable; + } + + public int Size => size; + + public void Write(BinaryWriter writer) + { + byte[] copyBuffer = new byte[256]; + + foreach (string name in names) + { + int length = Encoding.UTF8.GetBytes(name, 0, name.Length, copyBuffer, 0); + copyBuffer[length] = 0; + writer.Write(copyBuffer, 0, length + 1); + } + } + } + + #endregion + #region private class BinaryPartEntry + + private class BinaryPartEntry : IComparable + { + public readonly int SourceOffset; + public readonly string SourceFile; + public readonly int DestinationOffset; + public readonly int Size; + public readonly BinaryPartField Field; + + public BinaryPartEntry(string sourceFile, int sourceOffset, int size, int destinationOffset, Field field) + { + SourceFile = sourceFile; + SourceOffset = sourceOffset; + Size = size; + DestinationOffset = destinationOffset; + Field = (BinaryPartField)field; + } + + #region IComparable Members + + int IComparable.CompareTo(BinaryPartEntry other) + { + // + // Sort the binary parts by destination offset in an attempt to streamline the write IO + // + + return DestinationOffset.CompareTo(other.DestinationOffset); + } + + #endregion + } + + #endregion + #region private class ChecksumStream + + private class ChecksumStream : Stream + { + private int checksum; + private int position; + + public int Checksum => checksum; + + public override bool CanRead => false; + public override bool CanSeek => false; + public override bool CanWrite => true; + + public override void Flush() + { + } + + public override long Length => position; + + public override long Position + { + get + { + return position; + } + set + { + throw new NotSupportedException(); + } + } + + public override int Read(byte[] buffer, int offset, int count) + { + throw new NotSupportedException(); + } + + public override long Seek(long offset, SeekOrigin origin) + { + throw new NotSupportedException(); + } + + public override void SetLength(long value) + { + throw new NotSupportedException(); + } + + public override void Write(byte[] buffer, int offset, int count) + { + for (int i = offset; i < offset + count; i++) + checksum += buffer[i] ^ (i + position); + + position += count; + } + } + + #endregion + #region private class StreamCache + + private class StreamCache : IDisposable + { + private const int maxCacheSize = 32; + private Dictionary cacheEntries = new Dictionary(); + + private class CacheEntry + { + public BinaryReader Stream; + public long LastTimeUsed; + } + + public BinaryReader GetReader(InstanceDescriptor descriptor) + { + CacheEntry entry; + + if (!cacheEntries.TryGetValue(descriptor.FilePath, out entry)) + entry = OpenStream(descriptor); + + entry.LastTimeUsed = DateTime.Now.Ticks; + entry.Stream.Position = descriptor.DataOffset; + + return entry.Stream; + } + + private CacheEntry OpenStream(InstanceDescriptor descriptor) + { + CacheEntry oldestEntry = null; + string oldestDescriptor = null; + + if (cacheEntries.Count >= maxCacheSize) + { + foreach (KeyValuePair pair in cacheEntries) + { + if (oldestEntry == null || pair.Value.LastTimeUsed < oldestEntry.LastTimeUsed) + { + oldestDescriptor = pair.Key; + oldestEntry = pair.Value; + } + } + } + + if (oldestEntry == null) + { + oldestEntry = new CacheEntry(); + } + else + { + oldestEntry.Stream.Dispose(); + cacheEntries.Remove(oldestDescriptor); + } + + oldestEntry.Stream = new BinaryReader(descriptor.FilePath); + cacheEntries.Add(descriptor.FilePath, oldestEntry); + + return oldestEntry; + } + + public void Dispose() + { + foreach (CacheEntry entry in cacheEntries.Values) + entry.Stream.Dispose(); + } + } + + #endregion + + public static InstanceFileWriter CreateV31(long templateChecksum, bool bigEndian) + { + return new InstanceFileWriter(templateChecksum, InstanceFileHeader.Version31, bigEndian); + } + + public static InstanceFileWriter CreateV32(List descriptors) + { + long templateChecksum; + + if (descriptors.Exists(x => x.Template.Tag == TemplateTag.SNDD && x.IsMacFile)) + templateChecksum = InstanceFileHeader.OniMacTemplateChecksum; + else + templateChecksum = InstanceFileHeader.OniPCTemplateChecksum; + + var writer = new InstanceFileWriter(templateChecksum, InstanceFileHeader.Version32, false); + writer.AddDescriptors(descriptors, false); + return writer; + } + + private InstanceFileWriter(long templateChecksum, int version, bool bigEndian) + { + if (templateChecksum != InstanceFileHeader.OniPCTemplateChecksum + && templateChecksum != InstanceFileHeader.OniMacTemplateChecksum + && templateChecksum != 0) + { + throw new ArgumentException("Unknown template checksum", "templateChecksum"); + } + + this.bigEndian = bigEndian; + + header = new FileHeader + { + TemplateChecksum = templateChecksum, + Version = version + }; + + descriptorTable = new List(); + namedInstancedIdMap = new Dictionary(); + + linkMaps = new Dictionary(); + rawOffsetMaps = new Dictionary>(); + sepOffsetMaps = new Dictionary>(); + + sharedMap = new Dictionary(); + } + + public void AddDescriptors(List descriptors, bool removeDuplicates) + { + if (removeDuplicates) + { + Console.WriteLine("Removing duplicates"); + + using (streamCache = new StreamCache()) + descriptors = RemoveDuplicates(descriptors); + } + + // + // Initialize LinkMap table of each source file. + // + + var inputFiles = new Set(); + + foreach (var descriptor in descriptors) + inputFiles.Add(descriptor.File); + + foreach (var inputFile in inputFiles) + { + linkMaps[inputFile] = new int[inputFile.Descriptors.Count]; + rawOffsetMaps[inputFile] = new Dictionary(); + sepOffsetMaps[inputFile] = new Dictionary(); + } + + foreach (var descriptor in descriptors) + { + AddDescriptor(descriptor); + } + + CreateHeader(); + } + + private void AddDescriptor(InstanceDescriptor descriptor) + { + // + // SNDD instances are special because they are different between PC + // and Mac/PC Demo versions so we need to check if the instance type matches the + // output file type. If the file type wasn't specified then we will set it when + // the first SNDD instance is seen. + // + + if (descriptor.Template.Tag == TemplateTag.SNDD) + { + if (header.TemplateChecksum == 0) + { + header.TemplateChecksum = descriptor.TemplateChecksum; + } + else if (header.TemplateChecksum != descriptor.TemplateChecksum) + { + if (header.TemplateChecksum == InstanceFileHeader.OniMacTemplateChecksum) + throw new NotSupportedException(string.Format("File {0} cannot be imported due to conflicting template checksums", descriptor.FilePath)); + } + } + + // + // Create a new id for this descriptor and remember it and the old one + // in the LinkMap table of the source file. + // + + int id = MakeInstanceId(descriptorTable.Count); + + linkMaps[descriptor.File][descriptor.Index] = id; + + // + // If the descriptor has a name we will need to know later what is the new id + // for its name. + // + + if (descriptor.HasName) + namedInstancedIdMap[descriptor.FullName] = id; + + // + // Create and add new table entry for this descriptor. + // + + var entry = new DescriptorTableEntry(id, descriptor); + + if (!descriptor.IsPlaceholder) + { + // + // .oni files have only one non empty named descriptor. The rest are + // forced to be empty and their contents stored in separate .oni files. + // + + if (!IsV32 + || !descriptor.HasName + || descriptorTable.Count == 0 + || descriptorTable[0].SourceDescriptor == descriptor) + { + int dataSize = descriptor.DataSize; + + if (descriptor.Template.Tag == TemplateTag.SNDD + && header.TemplateChecksum == InstanceFileHeader.OniPCTemplateChecksum + && descriptor.TemplateChecksum == InstanceFileHeader.OniMacTemplateChecksum) + { + // + // HACK: when converting SNDD instances from PC Demo to PC Retail the resulting + // data size differs from the original. + // + + dataSize = 0x60; + } + else if (descriptor.Template.Tag == TemplateTag.AKDA) + { + dataSize = 0x20; + } + + entry.DataSize = dataSize; + entry.DataOffset = header.DataTableSize + 8; + + header.DataTableSize += entry.DataSize; + } + } + + descriptorTable.Add(entry); + } + + private void CreateHeader() + { + if (header.TemplateChecksum == 0) + throw new InvalidOperationException("Target file format was not specified and cannot be autodetected."); + + header.InstanceCount = descriptorTable.Count; + + int offset = FileHeader.Size + descriptorTable.Count * DescriptorTableEntry.Size; + + if (IsV31) + { + nameIndex = NameDescriptorTable.CreateFromDescriptors(descriptorTable); + + header.NameCount = nameIndex.Count; + offset += nameIndex.Size; + + templateTable = TemplateDescriptorTable.CreateFromDescriptors( + InstanceMetadata.GetMetadata(header.TemplateChecksum), + descriptorTable); + + header.TemplateCount = templateTable.Count; + offset += templateTable.Size; + + header.DataTableOffset = Utils.Align32(offset); + + nameTable = NameTable.CreateFromDescriptors(descriptorTable); + + header.NameTableSize = nameTable.Size; + header.NameTableOffset = Utils.Align32(header.DataTableOffset + header.DataTableSize); + } + else + { + // + // .oni files do not need the name index and the template table. + // They consume space, complicate things and the information + // contained in them can be recreated anyway. + // + + nameTable = NameTable.CreateFromDescriptors(descriptorTable); + + header.NameTableSize = nameTable.Size; + header.NameTableOffset = Utils.Align32(offset); + header.DataTableOffset = Utils.Align32(header.NameTableOffset + nameTable.Size); + header.RawTableOffset = Utils.Align32(header.DataTableOffset + header.DataTableSize); + } + } + + public void Write(string filePath) + { + string outputDirPath = Path.GetDirectoryName(filePath); + + Directory.CreateDirectory(outputDirPath); + + int fileId = IsV31 ? MakeFileId(filePath) : 0; + + using (streamCache = new StreamCache()) + using (var outputStream = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite, FileShare.None, 65536)) + using (var writer = new BinaryWriter(outputStream)) + { + outputStream.Position = FileHeader.Size; + + foreach (DescriptorTableEntry entry in descriptorTable) + { + entry.Write(writer, sharedMap.ContainsKey(entry.SourceDescriptor)); + } + + if (IsV31) + { + nameIndex.Write(writer); + templateTable.Write(writer); + } + else + { + // + // For .oni files write the name table before the data table + // for better reading performance at import time. + // + + writer.Position = header.NameTableOffset; + nameTable.Write(writer); + } + + WriteDataTable(writer, fileId); + + if (IsV31) + { + writer.Position = header.NameTableOffset; + nameTable.Write(writer); + } + + WriteBinaryParts(writer, filePath); + + if (IsV32 && outputStream.Length > header.RawTableOffset) + { + // + // The header was created with a RawTable size of 0 because + // we don't know the size in advance. Fix that now. + // + + header.RawTableSize = (int)outputStream.Length - header.RawTableOffset; + } + + outputStream.Position = 0; + header.Write(writer); + } + } + + private void WriteDataTable(BinaryWriter writer, int fileId) + { + writer.Position = header.DataTableOffset; + + // + // Raw and sep parts will be added as they are found. The initial offset + // is 32 because a 0 offset means "NULL". + // + + rawOffset = 32; + rawParts = new List(); + + sepOffset = 32; + sepParts = new List(); + + var entries = descriptorTable.ToArray(); + Array.Sort(entries, (x, y) => x.DataOffset.CompareTo(y.DataOffset)); + + foreach (var entry in entries) + { + if (entry.DataSize == 0) + continue; + + int padSize = header.DataTableOffset + entry.DataOffset - 8 - writer.Position; + + if (padSize <= 512) + writer.Write(padding, 0, padSize); + else + writer.Position = header.DataTableOffset + entry.DataOffset - 8; + + writer.Write(entry.Id); + writer.Write(fileId); + + var template = entry.SourceDescriptor.Template; + + if (template.Tag == TemplateTag.SNDD + && entry.SourceDescriptor.File.Header.TemplateChecksum == InstanceFileHeader.OniMacTemplateChecksum + && header.TemplateChecksum == InstanceFileHeader.OniPCTemplateChecksum) + { + // + // Special case to convert PC Demo SNDD files to PC Retail SNDD files. + // + + ConvertSNDDHack(entry, writer); + } + else + { + template.Type.Copy(streamCache.GetReader(entry.SourceDescriptor), writer, state => + { + if (state.Type == MetaType.RawOffset) + RemapRawOffset(entry, state); + else if (state.Type == MetaType.SepOffset) + RemapSepOffset(entry, state); + else if (state.Type is MetaPointer) + RemapLinkId(entry, state); + }); + + if (entry.Code == TemplateTag.TXMP) + { + // + // HACK: All .oni files use the PC format except the SNDD ones. Most + // differences between PC and Mac formats are handled by the metadata + // but the TXMP is special because the raw/sep offset field is at a + // different offset. + // + + ConvertTXMPHack(entry, writer.BaseStream); + } + } + } + } + + private void ConvertSNDDHack(DescriptorTableEntry entry, BinaryWriter writer) + { + var reader = streamCache.GetReader(entry.SourceDescriptor); + + int flags = reader.ReadInt32(); + int duration = reader.ReadInt32(); + int dataSize = reader.ReadInt32(); + int dataOffset = reader.ReadInt32(); + + int channelCount = (flags == 3) ? 2 : 1; + + writer.Write(8); + writer.WriteInt16(2); + writer.WriteInt16(channelCount); + writer.Write(22050); + writer.Write(11155); + writer.WriteInt16(512); + writer.WriteInt16(4); + writer.WriteInt16(32); + writer.Write(new byte[] { + 0xf4, 0x03, 0x07, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x02, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xc0, 0x00, 0x40, 0x00, 0xf0, 0x00, 0x00, 0x00, + 0xcc, 0x01, 0x30, 0xff, 0x88, 0x01, 0x18, 0xff + }); + + writer.Write((short)duration); + writer.Write(dataSize); + writer.Write(RemapRawOffsetCore(entry, dataOffset, null)); + } + + private void ConvertTXMPHack(DescriptorTableEntry entry, Stream stream) + { + stream.Position = header.DataTableOffset + entry.DataOffset + 0x80; + stream.Read(copyBuffer1, 0, 28); + + if (header.TemplateChecksum == InstanceFileHeader.OniPCTemplateChecksum) + { + // + // Swap Bytes is always set for PC files. + // + + copyBuffer1[1] |= 0x10; + } + else if (IsV31 && header.TemplateChecksum == InstanceFileHeader.OniMacTemplateChecksum) + { + // + // Swap Bytes if always set for MacPPC files except if the format is RGBA + // which requires no conversion. + // + + if (bigEndian && copyBuffer1[8] == (byte)Motoko.TextureFormat.RGBA) + copyBuffer1[1] &= 0xef; + else + copyBuffer1[1] |= 0x10; + } + + if (entry.SourceDescriptor.TemplateChecksum != header.TemplateChecksum) + { + // + // Swap the 0x94 and 0x98 fields to convert between Mac and PC TXMPs + // + + for (int i = 20; i < 24; i++) + { + byte b = copyBuffer1[i]; + copyBuffer1[i] = copyBuffer1[i + 4]; + copyBuffer1[i + 4] = b; + } + } + + stream.Position = header.DataTableOffset + entry.DataOffset + 0x80; + stream.Write(copyBuffer1, 0, 28); + } + + private bool ZeroTRAMPositionPointsHack(DescriptorTableEntry entry, CopyVisitor state) + { + if (entry.Code != TemplateTag.TRAM) + return false; + + int offset = state.GetInt32(); + + if (state.Position == 0x04) + { + entry.AnimationPositionPointHack = (offset == 0); + } + else if (state.Position == 0x28 && entry.AnimationPositionPointHack) + { + if (offset != 0) + { + InstanceFile input = entry.SourceFile; + int size = input.GetRawPartSize(offset); + offset = AllocateRawPart(null, 0, size, null); + state.SetInt32(offset); + } + + return true; + } + + return false; + } + + private void RemapRawOffset(DescriptorTableEntry entry, CopyVisitor state) + { + if (ZeroTRAMPositionPointsHack(entry, state)) + return; + + state.SetInt32(RemapRawOffsetCore(entry, state.GetInt32(), state.Field)); + } + + private int RemapRawOffsetCore(DescriptorTableEntry entry, int oldOffset, Field field) + { + if (oldOffset == 0) + return 0; + + InstanceFile input = entry.SourceFile; + Dictionary rawOffsetMap = rawOffsetMaps[input]; + int newOffset; + + if (!rawOffsetMap.TryGetValue(oldOffset, out newOffset)) + { + int size = input.GetRawPartSize(oldOffset); + + // + // .oni files are always in PC format (except SNDD files) so when importing + // to a Mac file we need to allocate some binary parts in the sep file + // instead of the raw file. + // + + if (header.TemplateChecksum == InstanceFileHeader.OniMacTemplateChecksum + && (entry.Code == TemplateTag.TXMP + || entry.Code == TemplateTag.OSBD + || entry.Code == TemplateTag.BINA)) + { + newOffset = AllocateSepPart(input.RawFilePath, oldOffset + input.Header.RawTableOffset, size, null); + } + else + { + newOffset = AllocateRawPart(input.RawFilePath, oldOffset + input.Header.RawTableOffset, size, field); + } + + rawOffsetMap[oldOffset] = newOffset; + } + + return newOffset; + } + + private void RemapSepOffset(DescriptorTableEntry entry, CopyVisitor state) + { + int oldOffset = state.GetInt32(); + + if (oldOffset == 0) + return; + + InstanceFile input = entry.SourceFile; + Dictionary sepOffsetMap = sepOffsetMaps[input]; + int newOffset; + + if (!sepOffsetMap.TryGetValue(oldOffset, out newOffset)) + { + int size = input.GetSepPartSize(oldOffset); + + // + // If we're writing a PC file then there is no sep file, everything gets allocated + // in the raw file + // + + if (header.TemplateChecksum == InstanceFileHeader.OniPCTemplateChecksum) + newOffset = AllocateRawPart(input.SepFilePath, oldOffset, size, null); + else + newOffset = AllocateSepPart(input.SepFilePath, oldOffset, size, null); + + sepOffsetMap[oldOffset] = newOffset; + } + + state.SetInt32(newOffset); + } + + private int AllocateRawPart(string sourceFile, int sourceOffset, int size, Field field) + { + var entry = new BinaryPartEntry(sourceFile, sourceOffset, size, rawOffset, field); + rawOffset = Utils.Align32(rawOffset + size); + rawParts.Add(entry); + return entry.DestinationOffset; + } + + private int AllocateSepPart(string sourceFile, int sourceOffset, int size, Field field) + { + var entry = new BinaryPartEntry(sourceFile, sourceOffset, size, sepOffset, field); + sepOffset = Utils.Align32(sepOffset + size); + sepParts.Add(entry); + return entry.DestinationOffset; + } + + private void RemapLinkId(DescriptorTableEntry entry, CopyVisitor state) + { + int oldId = state.GetInt32(); + + if (oldId != 0) + { + int newId = RemapLinkIdCore(entry.SourceDescriptor, oldId); + state.SetInt32(newId); + } + } + + private int RemapLinkIdCore(InstanceDescriptor descriptor, int id) + { + var file = descriptor.File; + + if (IsV31) + { + InstanceDescriptor oldDescriptor = file.GetDescriptor(id); + InstanceDescriptor newDescriptor; + int newDescriptorId; + + if (oldDescriptor.HasName) + { + // + // Always lookup named instances, this deals with cases where an instance from one source file + // is replaced by one from another source file. + // + + if (namedInstancedIdMap.TryGetValue(oldDescriptor.FullName, out newDescriptorId)) + return newDescriptorId; + } + + if (sharedMap.TryGetValue(oldDescriptor, out newDescriptor)) + return linkMaps[newDescriptor.File][newDescriptor.Index]; + } + + return linkMaps[file][id >> 8]; + } + + private void WriteBinaryParts(BinaryWriter writer, string filePath) + { + if (IsV32) + { + // + // For .oni files the raw/sep parts are written to the .oni file. + // Separate .raw/.sep files are not used. + // + + WriteParts(writer, rawParts); + return; + } + + string rawFilePath = Path.ChangeExtension(filePath, ".raw"); + + Console.WriteLine("Writing {0}", rawFilePath); + + using (var rawOutputStream = new FileStream(rawFilePath, FileMode.Create, FileAccess.Write, FileShare.None, 65536)) + using (var rawWriter = new BinaryWriter(rawOutputStream)) + { + WriteParts(rawWriter, rawParts); + } + + if (header.TemplateChecksum == InstanceFileHeader.OniMacTemplateChecksum) + { + // + // Only Mac/PC Demo files have a .sep file. + // + + string sepFilePath = Path.ChangeExtension(filePath, ".sep"); + + Console.WriteLine("Writing {0}", sepFilePath); + + using (var sepOutputStream = new FileStream(sepFilePath, FileMode.Create, FileAccess.Write, FileShare.None, 65536)) + using (var sepWriter = new BinaryWriter(sepOutputStream)) + { + WriteParts(sepWriter, sepParts); + } + } + } + + private void WriteParts(BinaryWriter writer, List binaryParts) + { + if (binaryParts.Count == 0) + { + writer.Write(padding, 0, 32); + return; + } + + binaryParts.Sort(); + + int fileLength = 0; + + foreach (BinaryPartEntry entry in binaryParts) + { + if (entry.DestinationOffset + entry.Size > fileLength) + fileLength = entry.DestinationOffset + entry.Size; + } + + if (IsV31) + writer.BaseStream.SetLength(fileLength); + else + writer.BaseStream.SetLength(fileLength + header.RawTableOffset); + + BinaryReader reader = null; + + foreach (BinaryPartEntry entry in binaryParts) + { + if (entry.SourceFile == null) + continue; + + if (reader == null) + { + reader = new BinaryReader(entry.SourceFile); + } + else if (reader.Name != entry.SourceFile) + { + reader.Dispose(); + reader = new BinaryReader(entry.SourceFile); + } + + reader.Position = entry.SourceOffset; + + // + // Smart change of output's stream position. This assumes that + // the binary parts are sorted by destination offset. + // + + int padSize = entry.DestinationOffset + header.RawTableOffset - writer.Position; + + if (padSize <= 32) + writer.Write(padding, 0, padSize); + else + writer.Position = entry.DestinationOffset + header.RawTableOffset; + + if (entry.Field == null || entry.Field.RawType == null) + { + // + // If we don't know the field or the fieldtype for this binary part + // we just copy it over without cleaning up garbage. + // + + if (copyBuffer1.Length < entry.Size) + copyBuffer1 = new byte[entry.Size * 2]; + + reader.Read(copyBuffer1, 0, entry.Size); + writer.Write(copyBuffer1, 0, entry.Size); + } + else + { + int size = entry.Size; + + while (size > 0) + { + int copiedSize = entry.Field.RawType.Copy(reader, writer, null); + + if (copiedSize > size) + throw new InvalidOperationException(string.Format("Bad metadata copying field {0}", entry.Field.Name)); + + size -= copiedSize; + } + } + } + + if (reader != null) + reader.Dispose(); + } + + private List RemoveDuplicates(List descriptors) + { + var checksums = new Dictionary>(); + var newDescriptorList = new List(descriptors.Count); + + foreach (var descriptor in descriptors) + { + // + // We only handle duplicates for these types of instances. + // These are the most common cases and they are simple to handle + // because they do not contain links to other instances. + // + + if (!(descriptor.Template.Tag == TemplateTag.IDXA + || descriptor.Template.Tag == TemplateTag.PNTA + || descriptor.Template.Tag == TemplateTag.VCRA + || descriptor.Template.Tag == TemplateTag.TXCA + || descriptor.Template.Tag == TemplateTag.TRTA + || descriptor.Template.Tag == TemplateTag.TRIA + || descriptor.Template.Tag == TemplateTag.ONCP + || descriptor.Template.Tag == TemplateTag.ONIA)) + { + newDescriptorList.Add(descriptor); + continue; + } + + int checksum = GetInstanceChecksum(descriptor); + + List existingDescriptors; + + if (!checksums.TryGetValue(checksum, out existingDescriptors)) + { + existingDescriptors = new List(); + checksums.Add(checksum, existingDescriptors); + } + else + { + InstanceDescriptor existing = existingDescriptors.Find(x => AreInstancesEqual(descriptor, x)); + + if (existing != null) + { + sharedMap.Add(descriptor, existing); + continue; + } + } + + existingDescriptors.Add(descriptor); + newDescriptorList.Add(descriptor); + } + + return newDescriptorList; + } + + private int GetInstanceChecksum(InstanceDescriptor descriptor) + { + using (var checksumStream = new ChecksumStream()) + using (var writer = new BinaryWriter(checksumStream)) + { + descriptor.Template.Type.Copy(streamCache.GetReader(descriptor), writer, null); + return checksumStream.Checksum; + } + } + + private bool AreInstancesEqual(InstanceDescriptor d1, InstanceDescriptor d2) + { + if (d1.File == d2.File && d1.Index == d2.Index) + return true; + + if (d1.Template.Tag != d2.Template.Tag + || d1.DataSize != d2.DataSize) + return false; + + if (copyBuffer1.Length < d1.DataSize) + copyBuffer1 = new byte[d1.DataSize * 2]; + + if (copyBuffer2.Length < d2.DataSize) + copyBuffer2 = new byte[d2.DataSize * 2]; + + MetaType type = d1.Template.Type; + + //return type.Compare(streamCache.GetStream(d1), streamCache.GetStream(d2)); + + using (var writer1 = new BinaryWriter(new MemoryStream(copyBuffer1))) + using (var writer2 = new BinaryWriter(new MemoryStream(copyBuffer2))) + { + int s1 = type.Copy(streamCache.GetReader(d1), writer1, null); + int s2 = type.Copy(streamCache.GetReader(d2), writer2, null); + + if (s1 != s2) + return false; + + for (int i = 0; i < s1; i++) + { + if (copyBuffer1[i] != copyBuffer2[i]) + return false; + } + } + + return true; + } + + private bool IsV31 => header.Version == InstanceFileHeader.Version31; + private bool IsV32 => header.Version == InstanceFileHeader.Version32; + + private static int MakeFileId(string filePath) + { + // + // File id is generated from the filename. The filename is expected to be in + // XXXXXN_YYYYY.dat format where the XXXXX (5 characters) part is ignored, N is treated + // as a number (level number) and the YYYYY (this part can have any length) is hashed. + // The file extension is ignored. + // + + string fileName = Path.GetFileNameWithoutExtension(filePath); + + if (fileName.Length < 6) + return 0; + + fileName = fileName.Substring(5); + + int levelNumber = 0; + int buildTypeHash = 0; + + int i = fileName.IndexOf('_'); + + if (i != -1) + { + int.TryParse(fileName.Substring(0, i), out levelNumber); + + if (!string.Equals(fileName.Substring(i + 1), "Final", StringComparison.Ordinal)) + { + for (int j = 1; i + j < fileName.Length; j++) + buildTypeHash += (char.ToUpperInvariant(fileName[i + j]) - 0x40) * j; + } + } + + return (((levelNumber << 24) | (buildTypeHash & 0xffffff)) << 1) | 1; + } + + public static int MakeInstanceId(int index) => (index << 8) | 1; + } +} Index: /OniSplit/Level/CameraImporter.cs =================================================================== --- /OniSplit/Level/CameraImporter.cs (revision 1114) +++ /OniSplit/Level/CameraImporter.cs (revision 1114) @@ -0,0 +1,90 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml; + +namespace Oni.Level +{ + using Physics; + + partial class LevelImporter + { + private void ReadCameras(XmlReader xml, string basePath) + { + if (!xml.IsStartElement("Cameras")) + return; + + if (xml.SkipEmpty()) + return; + + xml.ReadStartElement(); + + while (xml.IsStartElement()) + ReadCamera(xml, basePath); + + xml.ReadEndElement(); + } + + private void ReadCamera(XmlReader xml, string basePath) + { + var filePath = Path.Combine(basePath, xml.GetAttribute("Path")); + var scene = LoadScene(filePath); + var clips = new List(); + + if (filePath.Contains("Camout")) + { + Console.WriteLine(filePath); + } + + ReadSequence(xml, "Camera", name => + { + switch (name) + { + case "Animation": + clips.Add(ReadAnimationClip(xml)); + return true; + + default: + return false; + } + }); + + var props = new ObjectDaeNodeProperties(); + props.HasPhysics = true; + props.Animations.AddRange(clips); + + var importer = new ObjectDaeImporter(null, new Dictionary { { scene.Id, props } }); + + importer.Import(scene); + + foreach (var node in importer.Nodes) + { + foreach (var animation in node.Animations) + { + var writer = new DatWriter(); + ObjectDatWriter.WriteAnimation(animation, writer); + writer.Write(outputDirPath); + } + } + } + + private void ReadSequence(XmlReader xml, string name, Func action) + { + if (!xml.SkipEmpty()) + { + xml.ReadStartElement(name); + + while (xml.IsStartElement()) + { + if (!action(xml.LocalName)) + { + error.WriteLine("Unknown element {0}", xml.LocalName); + xml.Skip(); + } + } + + xml.ReadEndElement(); + } + } + } +} Index: /OniSplit/Level/CharacterImporter.cs =================================================================== --- /OniSplit/Level/CharacterImporter.cs (revision 1114) +++ /OniSplit/Level/CharacterImporter.cs (revision 1114) @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Xml; + +namespace Oni.Level +{ + partial class LevelImporter + { + private static IEnumerable ReadCharacters(XmlReader xml, string basePath) + { + if (xml.SkipEmpty()) + yield break; + + xml.ReadStartElement(); + + while (xml.IsStartElement()) + yield return ScriptCharacter.Read(xml); + + xml.ReadEndElement(); + } + } +} Index: /OniSplit/Level/Corpse.cs =================================================================== --- /OniSplit/Level/Corpse.cs (revision 1114) +++ /OniSplit/Level/Corpse.cs (revision 1114) @@ -0,0 +1,25 @@ +namespace Oni.Level +{ + internal class Corpse + { + public bool IsFixed; + public bool IsUsed; + public string FileName; + public string CharacterClass; + public readonly Matrix[] Transforms = new Matrix[19]; + public BoundingBox BoundingBox; + + public int Order + { + get + { + if (IsFixed) + return 1; + else if (IsUsed) + return 2; + else + return 3; + } + } + } +} Index: /OniSplit/Level/FilmImporter.cs =================================================================== --- /OniSplit/Level/FilmImporter.cs (revision 1114) +++ /OniSplit/Level/FilmImporter.cs (revision 1114) @@ -0,0 +1,247 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml; + +namespace Oni.Level +{ + using Metadata; + using Xml; + + partial class LevelImporter + { + private class Film + { + public string Name; + public Vector3 Position; + public float Facing; + public float DesiredFacing; + public float HeadFacing; + public float HeadPitch; + public readonly string[] Animations = new string[2]; + public int Length; + public readonly List Frames = new List(); + } + + private class FilmFrame + { + public Vector2 MouseDelta; + public InstanceMetadata.FILMKeys Keys; + public uint Time; + } + + private void ReadFilms(XmlReader xml, string basePath) + { + if (!xml.IsStartElement("Films") || xml.SkipEmpty()) + return; + + xml.ReadStartElement("Films"); + + while (xml.IsStartElement()) + { + xml.ReadStartElement("Import"); + string filePath = Path.Combine(basePath, xml.ReadElementContentAsString()); + xml.ReadEndElement(); + + if (!File.Exists(filePath)) + { + error.WriteLine("Could not find file '{0}'", filePath); + continue; + } + + string extension = Path.GetExtension(filePath); + string name = Path.GetFileNameWithoutExtension(filePath); + + if (string.Equals(extension, ".oni", StringComparison.OrdinalIgnoreCase)) + { + var outputFilePath = Path.Combine(outputDirPath, name + ".oni"); + + File.Copy(filePath, outputFilePath, true); + } + else if (string.Equals(extension, ".dat", StringComparison.OrdinalIgnoreCase)) + { + var film = ReadBinFilm(filePath); + + var datWriter = new DatWriter(); + WriteDatFilm(datWriter, film); + datWriter.Write(outputDirPath); + } + else if (string.Equals(extension, ".xml", StringComparison.OrdinalIgnoreCase)) + { + var film = ReadXmlFilm(filePath); + + var datWriter = new DatWriter(); + WriteDatFilm(datWriter, film); + datWriter.Write(outputDirPath); + } + else + { + error.WriteLine("Unsupported film file type {0}", extension); + } + } + + xml.ReadEndElement(); + } + + private static Film ReadBinFilm(string filePath) + { + string name = Path.GetFileNameWithoutExtension(filePath); + + if (name.StartsWith("FILM", StringComparison.Ordinal)) + name = name.Substring(4); + + var film = new Film(); + film.Name = name; + + using (var reader = new BinaryReader(filePath, true)) + { + film.Animations[0] = reader.ReadString(128); + film.Animations[1] = reader.ReadString(128); + film.Position = reader.ReadVector3(); + film.Facing = reader.ReadSingle(); + film.DesiredFacing = reader.ReadSingle(); + film.HeadFacing = reader.ReadSingle(); + film.HeadPitch = reader.ReadSingle(); + film.Length = reader.ReadInt32(); + reader.Skip(28); + int numFrames = reader.ReadInt32(); + film.Frames.Capacity = numFrames; + + for (int i = 0; i < numFrames; i++) + { + var frame = new FilmFrame(); + frame.MouseDelta = reader.ReadVector2(); + frame.Keys = (InstanceMetadata.FILMKeys)reader.ReadUInt64(); + frame.Time = reader.ReadUInt32(); + reader.Skip(4); + film.Frames.Add(frame); + } + } + + return film; + } + + private static Film ReadXmlFilm(string filePath) + { + string name = Path.GetFileNameWithoutExtension(filePath); + + if (name.StartsWith("FILM", StringComparison.Ordinal)) + name = name.Substring(4); + + var film = new Film(); + film.Name = name; + + var settings = new XmlReaderSettings { + IgnoreWhitespace = true, + IgnoreProcessingInstructions = true, + IgnoreComments = true + }; + + using (var xml = XmlReader.Create(filePath, settings)) + { + xml.ReadStartElement("Oni"); + + name = xml.GetAttribute("Name"); + + if (!string.IsNullOrEmpty(name)) + film.Name = name; + + xml.ReadStartElement("FILM"); + + film.Position = xml.ReadElementContentAsVector3("Position"); + film.Facing = xml.ReadElementContentAsFloat("Facing", ""); + film.DesiredFacing = xml.ReadElementContentAsFloat("DesiredFacing", ""); + film.HeadFacing = xml.ReadElementContentAsFloat("HeadFacing", ""); + film.HeadPitch = xml.ReadElementContentAsFloat("HeadPitch", ""); + film.Length = xml.ReadElementContentAsInt("FrameCount", ""); + xml.ReadStartElement("Animations"); + film.Animations[0] = xml.ReadElementContentAsString("Link", ""); + film.Animations[1] = xml.ReadElementContentAsString("Link", ""); + xml.ReadEndElement(); + xml.ReadStartElement("Frames"); + + while (xml.IsStartElement()) + { + var frame = new FilmFrame(); + + switch (xml.LocalName) + { + case "FILMFrame": + xml.ReadStartElement(); + frame.MouseDelta.X = xml.ReadElementContentAsFloat("MouseDeltaX", ""); + frame.MouseDelta.Y = xml.ReadElementContentAsFloat("MouseDeltaY", ""); + frame.Keys = xml.ReadElementContentAsEnum("Keys"); + frame.Time = (uint)xml.ReadElementContentAsInt("Frame", ""); + xml.ReadEndElement(); + break; + + case "Frame": + xml.ReadStartElement(); + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "Time": + frame.Time = (uint)xml.ReadElementContentAsInt(); + break; + case "MouseDelta": + frame.MouseDelta = xml.ReadElementContentAsVector2(); + break; + case "Keys": + frame.Keys = xml.ReadElementContentAsEnum(); + break; + } + } + xml.ReadEndElement(); + break; + default: + xml.Skip(); + continue; + } + + film.Frames.Add(frame); + + } + + xml.ReadEndElement(); + xml.ReadEndElement(); + } + + return film; + } + + private static void WriteDatFilm(DatWriter filmWriter, Film film) + { + var descriptor = filmWriter.CreateInstance(TemplateTag.FILM, film.Name); + + var animations = new ImporterDescriptor[2]; + + for (int i = 0; i < animations.Length; i++) + { + if (!string.IsNullOrEmpty(film.Animations[i])) + animations[i] = filmWriter.CreateInstance(TemplateTag.TRAM, film.Animations[i]); + } + + using (var writer = descriptor.OpenWrite()) + { + writer.Write(film.Position); + writer.Write(film.Facing); + writer.Write(film.DesiredFacing); + writer.Write(film.HeadFacing); + writer.Write(film.HeadPitch); + writer.Write(film.Length); + writer.Write(animations); + writer.Skip(12); + writer.Write(film.Frames.Count); + + foreach (var frame in film.Frames) + { + writer.Write(frame.MouseDelta); + writer.Write((ulong)frame.Keys); + writer.Write(frame.Time); + writer.Skip(4); + } + } + } + } +} Index: /OniSplit/Level/Later/EnvParticle.cs =================================================================== --- /OniSplit/Level/Later/EnvParticle.cs (revision 1114) +++ /OniSplit/Level/Later/EnvParticle.cs (revision 1114) @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Oni.Level +{ + internal class EnvParticle + { + public string ClassName; + public string Name; + public Matrix Matrix; + public Vector2 DecalScale; + } +} Index: /OniSplit/Level/Later/Level.cs =================================================================== --- /OniSplit/Level/Later/Level.cs (revision 1114) +++ /OniSplit/Level/Later/Level.cs (revision 1114) @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Oni.Level +{ + internal class Level + { + public string Name; + } +} Index: /OniSplit/Level/Later/LevelDatReader.cs =================================================================== --- /OniSplit/Level/Later/LevelDatReader.cs (revision 1114) +++ /OniSplit/Level/Later/LevelDatReader.cs (revision 1114) @@ -0,0 +1,171 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Oni.Level +{ + internal class LevelDatReader + { + private InstanceDescriptor onlv; + private BinaryReader dat; + private Level level; + + public static Level Read(InstanceDescriptor onlv, BinaryReader dat) + { + LevelDatReader reader = new LevelDatReader(); + reader.onlv = onlv; + reader.dat = dat; + reader.level = new Level(); + reader.Read(); + return reader.level; + } + + private void Read() + { + InstanceDescriptor akev; + InstanceDescriptor oboa; + InstanceDescriptor onsk; + InstanceDescriptor aisa; + InstanceDescriptor onoa; + InstanceDescriptor envp; + InstanceDescriptor crsa; + + level.Name = dat.ReadString(64); + akev = dat.ReadInstance(); + oboa = dat.ReadInstance(); + dat.Skip(12); + onsk = dat.ReadInstance(); + dat.Skip(4); + aisa = dat.ReadInstance(); + dat.Skip(12); + onoa = dat.ReadInstance(); + envp = dat.ReadInstance(); + dat.Skip(644); + crsa = dat.ReadInstance(); + } + + private void ReadOBOA(InstanceDescriptor oboa) + { + List objects = new List(); + + using (BinaryReader reader = oboa.OpenRead()) + { + reader.Skip(22); + int count = reader.ReadUInt16(); + + for (int i = 0; i < count; i++) + { + InstanceDescriptor m3ga = reader.ReadInstance(); + InstanceDescriptor oban = reader.ReadInstance(); + InstanceDescriptor envp = reader.ReadInstance(); + PhyObjectFlags flags = (PhyObjectFlags)reader.ReadInt32(); + reader.Skip(4); + int doorId = reader.ReadInt32(); + PhyType phyType = (PhyType)reader.ReadInt32(); + int scriptId = reader.ReadInt32(); + Vector3 position = reader.ReadVector3(); + Quaternion rotation = reader.ReadQuaternion(); + float scale = reader.ReadSingle(); + Matrix matrix = reader.ReadMatrix4x3(); + string name = reader.ReadString(64); + string fileName = reader.ReadString(64); + + if ((flags & PhyObjectFlags.Used) == 0) + continue; + } + } + } + + private void ReadENVP(InstanceDescriptor envp) + { + List objects = new List(); + + using (BinaryReader reader = envp.OpenRead()) + { + reader.Skip(22); + int count = reader.ReadUInt16(); + + for (int i = 0; i < count; i++) + { + string className = reader.ReadString(64); + string name = reader.ReadString(48); + Matrix matrix = reader.ReadMatrix4x3(); + Vector2 decalScale = reader.ReadVector2(); + reader.Skip(40); + } + } + } + + private class DatObjectQuads + { + public uint ObjectId; + public int[] QuadIndices; + } + + private void ReadONOA(InstanceDescriptor onoa) + { + List objects = new List(); + List indices = new List(); + + using (BinaryReader reader = onoa.OpenRead()) + { + reader.Skip(20); + int count = reader.ReadInt32(); + + for (int i = 0; i < count; i++) + { + uint id = reader.ReadUInt32(); + InstanceDescriptor idxa = reader.ReadInstance(); + + DatObjectQuads obj = new DatObjectQuads(); + obj.ObjectId = id; + objects.Add(obj); + indices.Add(idxa); + } + } + + for (int i = 0; i < objects.Count; i++) + { + using (BinaryReader reader = indices[i].OpenRead()) + { + reader.Skip(20); + objects[i].QuadIndices = reader.ReadInt32VarArray(); + } + } + } + + private void ReadAISA(InstanceDescriptor aisa) + { + List chars = new List(); + + using (BinaryReader reader = aisa.OpenRead()) + { + reader.Skip(22); + int count = reader.ReadUInt16(); + + for (int i = 0; i < count; i++) + { + string name = reader.ReadString(32); + int id = reader.ReadUInt16(); + int flagId = reader.ReadUInt16(); + reader.Skip(2); + int teamId = reader.ReadUInt16(); + InstanceDescriptor oncc = reader.ReadInstance(); + reader.Skip(32); + reader.Skip(4); + string createScript = reader.ReadString(32); + string dieScript = reader.ReadString(32); + string enemyScript = reader.ReadString(32); + string alarmScript = reader.ReadString(32); + string hurtScript = reader.ReadString(32); + string lowHealthScript = reader.ReadString(32); + string lowAmmoScript = reader.ReadString(32); + string noPathScript = reader.ReadString(32); + InstanceDescriptor onwc = reader.ReadInstance(); + int ammo = reader.ReadUInt16(); + reader.Skip(10); + } + } + } + } +} Index: /OniSplit/Level/Later/PhyObject.cs =================================================================== --- /OniSplit/Level/Later/PhyObject.cs (revision 1114) +++ /OniSplit/Level/Later/PhyObject.cs (revision 1114) @@ -0,0 +1,25 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Oni.Level +{ + internal class PhyObject + { + public PhyObjectFlags Flags; + public PhyType PhysicsType; + public int ScriptId; + public List Particles; + + public Vector3 Position; + public Quaternion Rotation; + public float Scale; + public Matrix Matrix; + + public int DoorId; + public int DoorQuad; + + public string Name; + public string FileName; + } +} Index: /OniSplit/Level/Later/PhyObjectFlags.cs =================================================================== --- /OniSplit/Level/Later/PhyObjectFlags.cs (revision 1114) +++ /OniSplit/Level/Later/PhyObjectFlags.cs (revision 1114) @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Oni.Level +{ + [Flags] + internal enum PhyObjectFlags + { + Used = 0x20000, + NoCollision = 0x40000, + NoGravity = 0x80000, + BoxCollision = 0x100000, + } +} Index: /OniSplit/Level/Later/PhyType.cs =================================================================== --- /OniSplit/Level/Later/PhyType.cs (revision 1114) +++ /OniSplit/Level/Later/PhyType.cs (revision 1114) @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Oni.Level +{ + internal enum PhyType + { + None0, + None1, + HasPhysics2, + IsAnimated3, + HasPhysics4 + } +} Index: /OniSplit/Level/Later/ScriptCharacter.cs =================================================================== --- /OniSplit/Level/Later/ScriptCharacter.cs (revision 1114) +++ /OniSplit/Level/Later/ScriptCharacter.cs (revision 1114) @@ -0,0 +1,10 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Oni.Level +{ + internal class ScriptCharacter + { + } +} Index: /OniSplit/Level/LevelDatWriter.cs =================================================================== --- /OniSplit/Level/LevelDatWriter.cs (revision 1114) +++ /OniSplit/Level/LevelDatWriter.cs (revision 1114) @@ -0,0 +1,331 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Level +{ + internal class LevelDatWriter + { + private readonly Importer importer; + private readonly DatLevel level; + + public class DatLevel + { + public string name; + public string skyName; + public readonly List physics = new List(); + public readonly List particles = new List(); + public readonly List characters = new List(); + public readonly List corpses = new List(); + public Akira.PolygonMesh model; + } + + private LevelDatWriter(Importer importer, DatLevel level) + { + this.importer = importer; + this.level = level; + } + + public static void Write(Importer importer, DatLevel level) + { + var writer = new LevelDatWriter(importer, level); + writer.WriteONLV(); + } + + private void WriteONLV() + { + var onlv = importer.CreateInstance(TemplateTag.ONLV, level.name); + var oboa = importer.CreateInstance(TemplateTag.OBOA); + var aisa = importer.CreateInstance(TemplateTag.AISA); + var onoa = importer.CreateInstance(TemplateTag.ONOA); + var envp = importer.CreateInstance(TemplateTag.ENVP); + var crsa = importer.CreateInstance(TemplateTag.CRSA); + var onsk = importer.CreateInstance(TemplateTag.ONSK, level.skyName); + var akev = importer.CreateInstance(TemplateTag.AKEV, level.name); + + using (var writer = onlv.OpenWrite()) + { + writer.Write(level.name, 64); + writer.Write(akev); + writer.Write(oboa); + writer.Write(0); + writer.Write(0); + writer.Write(0); + writer.Write(onsk); + writer.Write(0.0f); + writer.Write(aisa); + writer.Write(0); + writer.Write(0); + writer.Write(0); + writer.Write(onoa); + writer.Write(envp); + writer.Skip(644); + writer.Write(crsa); + } + + WriteOBOA(oboa); + WriteAISA(aisa); + WriteONOA(onoa); + WriteENVP(envp, level.particles); + WriteCRSA(crsa, level.corpses); + } + + private void WriteOBOA(ImporterDescriptor oboa) + { + var objects = level.physics; + var m3ga = new ImporterDescriptor[objects.Count]; + var oban = new ImporterDescriptor[objects.Count]; + var envp = new ImporterDescriptor[objects.Count]; + + for (int i = 0; i < objects.Count; i++) + { + var obj = objects[i]; + + var m3gms = new List(); + + foreach (var geom in obj.Geometries) + { + if (geom is string) + m3gms.Add(importer.CreateInstance(TemplateTag.M3GM, (string)geom)); + else + m3gms.Add(Motoko.GeometryDatWriter.Write((Motoko.Geometry)geom, importer.ImporterFile)); + } + + m3ga[i] = importer.CreateInstance(TemplateTag.M3GA); + + WriteM3GA(m3ga[i], m3gms); + + if (obj.Animation != null) + oban[i] = importer.CreateInstance(TemplateTag.OBAN, obj.Animation.Name); + + if (obj.Particles.Count > 0) + { + envp[i] = importer.CreateInstance(TemplateTag.ENVP); + WriteENVP(envp[i], obj.Particles); + } + } + + int unused = 32; + + using (var writer = oboa.OpenWrite(22)) + { + writer.WriteUInt16(objects.Count + unused); + + for (int i = 0; i != objects.Count; i++) + { + var obj = objects[i]; + + writer.Write(m3ga[i]); + writer.Write(oban[i]); + writer.Write(envp[i]); + writer.Write((uint)(obj.Flags | Physics.ObjectSetupFlags.InUse)); + //writer.Write(obj.DoorGunkIndex); + writer.Write(0); + writer.Write(obj.DoorScriptId); + writer.Write((uint)obj.PhysicsType); + writer.Write(obj.ScriptId); + writer.Write(obj.Position); + writer.Write(obj.Orientation); + writer.Write(obj.Scale); + writer.WriteMatrix4x3(obj.Origin); + writer.Write(obj.Name, 64); + writer.Write(obj.FileName, 64); + } + + writer.Skip(unused * 240); + } + } + + private void WriteM3GA(ImporterDescriptor m3ga, ICollection geometries) + { + using (var writer = m3ga.OpenWrite(20)) + { + writer.Write(geometries.Count); + writer.Write(geometries); + } + } + + private void WriteAISA(ImporterDescriptor aisa) + { + var characterClasses = new Dictionary(StringComparer.Ordinal); + var weaponClasses = new Dictionary(StringComparer.Ordinal); + + foreach (var chr in level.characters) + { + if (!characterClasses.ContainsKey(chr.className)) + characterClasses.Add(chr.className, importer.CreateInstance(TemplateTag.ONCC, chr.className)); + + if (!string.IsNullOrEmpty(chr.weaponClassName) && !weaponClasses.ContainsKey(chr.weaponClassName)) + weaponClasses.Add(chr.weaponClassName, importer.CreateInstance(TemplateTag.ONWC, chr.weaponClassName)); + } + + using (var writer = aisa.OpenWrite(22)) + { + writer.WriteUInt16(level.characters.Count); + + foreach (var chr in level.characters) + { + ImporterDescriptor characterClass, weaponClass; + + characterClasses.TryGetValue(chr.className, out characterClass); + + if (!string.IsNullOrEmpty(chr.weaponClassName)) + weaponClasses.TryGetValue(chr.weaponClassName, out weaponClass); + else + weaponClass = null; + + writer.Write(chr.name, 32); + writer.WriteInt16(chr.scriptId); + writer.WriteInt16(chr.flagId); + writer.WriteUInt16((ushort)chr.flags); + writer.WriteUInt16((ushort)chr.team); + writer.Write(characterClass); + writer.Skip(36); + writer.Write(chr.onSpawn, 32); + writer.Write(chr.onDeath, 32); + writer.Write(chr.onSeenEnemy, 32); + writer.Write(chr.onAlarmed, 32); + writer.Write(chr.onHurt, 32); + writer.Write(chr.onDefeated, 32); + writer.Write(chr.onOutOfAmmo, 32); + writer.Write(chr.onNoPath, 32); + writer.Write(weaponClass); + writer.WriteInt16(chr.ammo); + writer.Skip(10); + } + } + } + + private void WriteONOA(ImporterDescriptor onoa) + { + var map = new Dictionary>(); + int pi = 0; + + foreach (var poly in level.model.Polygons) + { + if (poly.ObjectId > 0) + { + List indices; + + int objectId = poly.ObjectType << 24 | poly.ObjectId; + + if (!map.TryGetValue(objectId, out indices)) + { + indices = new List(); + map[objectId] = indices; + } + + indices.Add(pi); + } + + pi++; + } + + var elt = new List>(); + + foreach (var pair in map) + { + var idxa = importer.CreateInstance(TemplateTag.IDXA); + + elt.Add(new KeyValuePair(pair.Key, idxa)); + + using (var idxaWriter = idxa.OpenWrite(20)) + { + idxaWriter.Write(pair.Value.Count); + idxaWriter.Write(pair.Value.ToArray()); + } + } + + using (var writer = onoa.OpenWrite(20)) + { + writer.Write(elt.Count); + + foreach (var e in elt) + { + writer.Write(e.Key); + writer.Write(e.Value); + } + } + } + + private void WriteENVP(ImporterDescriptor envp, List particles) + { + using (var writer = envp.OpenWrite(22)) + { + writer.WriteUInt16(particles.Count); + + foreach (var particle in particles) + { + writer.Write(particle.ParticleClass, 64); + writer.Write(particle.Tag, 48); + writer.WriteMatrix4x3(particle.Matrix); + writer.Write(particle.DecalScale); + writer.Write((ushort)particle.Flags); + writer.Skip(38); + } + } + } + + private void WriteCRSA(ImporterDescriptor crsa, List corpses) + { + // + // Ensure that there are at least 20 corpses + // + + while (corpses.Count < 20) + corpses.Add(new Corpse()); + + int fixedCount = corpses.Count(c => c.IsFixed); + int usedCount = corpses.Count(c => c.IsUsed); + + // + // Ensure that there are at least 5 unused corpses + // so new corpses can be created at runtime + // + + while (corpses.Count - usedCount < 5) + corpses.Add(new Corpse()); + + corpses.Sort((x, y) => x.Order.CompareTo(y.Order)); + + var onccDesriptors = new Dictionary(); + + using (var writer = crsa.OpenWrite(12)) + { + writer.Write(fixedCount); + writer.Write(usedCount); + writer.Write(corpses.Count); + + foreach (var corpse in corpses) + { + writer.Write(corpse.FileName ?? "", 32); + writer.Skip(128); + + if (corpse.IsUsed) + { + ImporterDescriptor oncc = null; + + if (!string.IsNullOrEmpty(corpse.CharacterClass)) + { + if (!onccDesriptors.TryGetValue(corpse.CharacterClass, out oncc)) + { + oncc = importer.CreateInstance(TemplateTag.ONCC, corpse.CharacterClass); + onccDesriptors.Add(corpse.CharacterClass, oncc); + } + } + + writer.Write(oncc); + + foreach (var transform in corpse.Transforms) + writer.WriteMatrix4x3(transform); + + writer.Write(corpse.BoundingBox); + } + else + { + writer.Skip(940); + } + } + } + } + } +} Index: /OniSplit/Level/LevelImporter.cs =================================================================== --- /OniSplit/Level/LevelImporter.cs (revision 1114) +++ /OniSplit/Level/LevelImporter.cs (revision 1114) @@ -0,0 +1,146 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml; + +namespace Oni.Level +{ + internal partial class LevelImporter : Importer + { + private readonly TextWriter info; + private readonly TextWriter error; + private bool debug; + private string outputDirPath; + private LevelDatWriter.DatLevel level; + private string sharedPath; + private InstanceFileManager sharedManager; + private Dictionary sharedCache; + private Dictionary sceneCache; + + public LevelImporter() + { + info = Console.Out; + error = Console.Error; + } + + public bool Debug + { + get { return debug; } + set { debug = value; } + } + + public override void Import(string filePath, string outputDirPath) + { + this.outputDirPath = outputDirPath; + this.textureImporter = new Motoko.TextureImporter3(outputDirPath); + + Read(filePath); + + WriteLevel(); + WriteObjects(); + } + + private void Read(string filePath) + { + level = new LevelDatWriter.DatLevel(); + level.name = Path.GetFileNameWithoutExtension(filePath); + + string basePath = Path.GetDirectoryName(filePath); + + var settings = new XmlReaderSettings { + IgnoreWhitespace = true, + IgnoreProcessingInstructions = true, + IgnoreComments = true + }; + + using (var xml = XmlReader.Create(filePath, settings)) + { + xml.ReadStartElement("Oni"); + ReadLevel(xml, basePath); + xml.ReadEndElement(); + } + + ImportModel(basePath); + } + + private void ReadLevel(XmlReader xml, string basePath) + { + string path = xml.GetAttribute("SharedPath"); + + if (!string.IsNullOrEmpty(path)) + sharedPath = Path.GetFullPath(Path.Combine(basePath, path)); + else + sharedPath = Path.GetFullPath(Path.Combine(basePath, "classes")); + + sharedManager = new InstanceFileManager(); + sharedManager.AddSearchPath(sharedPath); + + string name = xml.GetAttribute("Name"); + + if (!string.IsNullOrEmpty(name)) + level.name = name; + + xml.ReadStartElement("Level"); + + ReadModel(xml, basePath); + ReadSky(xml, basePath); + ReadObjects(xml, basePath); + ReadFilms(xml, basePath); + ReadCameras(xml, basePath); + + xml.ReadEndElement(); + } + + private void WriteLevel() + { + BeginImport(); + LevelDatWriter.Write(this, level); + Write(outputDirPath); + textureImporter.Write(); + } + + private Dae.Scene LoadScene(string filePath) + { + if (sceneCache == null) + { + sceneCache = new Dictionary(StringComparer.OrdinalIgnoreCase); + } + + filePath = Path.GetFullPath(filePath); + Dae.Scene scene; + + if (!sceneCache.TryGetValue(filePath, out scene)) + { + scene = Dae.Reader.ReadFile(filePath); + sceneCache.Add(filePath, scene); + } + + return scene; + } + + private InstanceDescriptor FindSharedInstance(TemplateTag tag, string name) + { + if (sharedCache == null) + sharedCache = new Dictionary(StringComparer.Ordinal); + + string fullName = tag.ToString() + name; + InstanceDescriptor descriptor; + + if (!sharedCache.TryGetValue(fullName, out descriptor)) + { + var file = sharedManager.FindInstance(fullName); + + if (file == null) + error.WriteLine("Could not find {0} instance {1}", tag, name); + else if (file.Descriptors[0].Template.Tag != tag) + error.WriteLine("Found '{0}' but its type {1} doesn't match the expected type {2}", name, file.Descriptors[0].Template.Tag, tag); + else + descriptor = file.Descriptors[0]; + + sharedCache.Add(fullName, descriptor); + } + + return descriptor; + } + } +} Index: /OniSplit/Level/ModelImporter.cs =================================================================== --- /OniSplit/Level/ModelImporter.cs (revision 1114) +++ /OniSplit/Level/ModelImporter.cs (revision 1114) @@ -0,0 +1,527 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml; + +namespace Oni.Level +{ + using Akira; + using Metadata; + using Motoko; + using Physics; + + partial class LevelImporter + { + private List roomScenes; + private PolygonMesh model; + private AkiraDaeReader daeReader; + + private void ReadModel(XmlReader xml, string basePath) + { + xml.ReadStartElement("Environment"); + + xml.ReadStartElement("Model"); + + daeReader = new AkiraDaeReader(); + model = daeReader.Mesh; + level.model = model; + + info.WriteLine("Reading environment..."); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "Import": + case "Scene": + ImportModelScene(xml, basePath); + break; + + case "Object": + xml.Skip(); + break; + + case "Camera": + ReadCamera(xml, basePath); + break; + + case "Texture": + textureImporter.ReadOptions(xml, basePath); + break; + + default: + error.WriteLine("Unknown element {0}", xml.LocalName); + xml.Skip(); + break; + } + } + + info.WriteLine("Reading rooms..."); + + roomScenes = new List(); + + xml.ReadEndElement(); + xml.ReadStartElement("Rooms"); + + while (xml.IsStartElement("Import")) + { + string filePath = xml.GetAttribute("Path"); + + if (filePath == null) + filePath = xml.ReadElementContentAsString(); + else + xml.Skip(); + + filePath = Path.Combine(basePath, filePath); + + roomScenes.Add(LoadScene(filePath)); + } + + xml.ReadEndElement(); + + if (xml.IsStartElement("Textures")) + ReadTextures(xml, basePath); + + xml.ReadEndElement(); + } + + private class NodePropertiesReader + { + private readonly string basePath; + private readonly TextWriter error; + public readonly Dictionary properties = new Dictionary(StringComparer.Ordinal); + + public NodePropertiesReader(string basePath, TextWriter error) + { + this.basePath = basePath; + this.error = error; + } + + public Dictionary Properties + { + get { return properties; } + } + + public void ReadScene(XmlReader xml, Dae.Node scene) + { + var nodeProperties = new ObjectDaeNodeProperties(); + properties.Add(scene.Id, nodeProperties); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "GunkFlags": + nodeProperties.GunkFlags = xml.ReadElementContentAsEnum(); + break; + case "ScriptId": + nodeProperties.ScriptId = xml.ReadElementContentAsInt(); + break; + case "Node": + ReadNode(xml, scene, nodeProperties); + break; + default: + xml.Skip(); + break; + } + } + } + + private void ReadNode(XmlReader xml, Dae.Node parentNode, ObjectDaeNodeProperties parentNodeProperties) + { + string id = xml.GetAttribute("Id"); + + if (string.IsNullOrEmpty(id)) + { + error.Write("Each import node must have an Id attribute"); + xml.Skip(); + return; + } + + var nodeProperties = new ObjectDaeNodeProperties { + GunkFlags = parentNodeProperties.GunkFlags, + ScriptId = parentNodeProperties.ScriptId, + HasPhysics = parentNodeProperties.HasPhysics + }; + + properties.Add(id, nodeProperties); + + xml.ReadStartElement("Node"); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "GunkFlags": + nodeProperties.GunkFlags |= xml.ReadElementContentAsEnum(); + break; + case "ScriptId": + nodeProperties.ScriptId = xml.ReadElementContentAsInt(); + break; + case "Physics": + nodeProperties.PhysicsType = xml.ReadElementContentAsEnum(); + nodeProperties.HasPhysics = true; + break; + case "ObjectFlags": + nodeProperties.ObjectFlags = xml.ReadElementContentAsEnum(); + nodeProperties.HasPhysics = true; + break; + case "Animation": + nodeProperties.Animations.Add(ReadAnimationClip(xml)); + nodeProperties.HasPhysics = true; + break; + case "Particles": + nodeProperties.Particles.AddRange(ReadParticles(xml, basePath)); + nodeProperties.HasPhysics = true; + break; + default: + error.WriteLine("Unknown physics object element {0}", xml.LocalName); + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + } + + private ObjectAnimationClip ReadAnimationClip(XmlReader xml) + { + var animClip = new ObjectAnimationClip(xml.GetAttribute("Name")); + + if (!xml.SkipEmpty()) + { + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "Start": + animClip.Start = xml.ReadElementContentAsInt(); + break; + case "Stop": + animClip.Stop = xml.ReadElementContentAsInt(); + break; + case "End": + animClip.End = xml.ReadElementContentAsInt(); + break; + case "Flags": + animClip.Flags = xml.ReadElementContentAsEnum(); + break; + default: + error.WriteLine("Unknown object animation property {0}", xml.LocalName); + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + } + + return animClip; + } + } + + private void ImportModelScene(XmlReader xml, string basePath) + { + var filePath = Path.Combine(basePath, xml.GetAttribute("Path")); + var scene = LoadScene(filePath); + + var propertiesReader = new NodePropertiesReader(basePath, error); + + if (!xml.SkipEmpty()) + { + xml.ReadStartElement(); + propertiesReader.ReadScene(xml, scene); + xml.ReadEndElement(); + } + + daeReader.ReadScene(scene, propertiesReader.Properties); + + if (propertiesReader.Properties.Values.Any(p => p.HasPhysics)) + { + var imp = new ObjectDaeImporter(textureImporter, propertiesReader.Properties); + + imp.Import(scene); + + foreach (var node in imp.Nodes.Where(n => n.Geometries.Length > 0)) + { + var setup = new ObjectSetup { + Name = node.Name, + FileName = node.FileName, + ScriptId = node.ScriptId, + Flags = node.Flags, + PhysicsType = ObjectPhysicsType.Animated + }; + + setup.Geometries = node.Geometries + .Where(n => (n.Flags & GunkFlags.Invisible) == 0) + .Select(n => n.Geometry.Name).ToArray(); + + foreach (var nodeGeometry in node.Geometries.Where(g => (g.Flags & GunkFlags.Invisible) == 0)) + { + var writer = new DatWriter(); + GeometryDatWriter.Write(nodeGeometry.Geometry, writer.ImporterFile); + writer.Write(outputDirPath); + } + + setup.Position = Vector3.Zero; + setup.Orientation = Quaternion.Identity; + setup.Scale = 1.0f; + setup.Origin = Matrix.CreateFromQuaternion(setup.Orientation) + * Matrix.CreateScale(setup.Scale) + * Matrix.CreateTranslation(setup.Position); + + //int i = 0; + + foreach (var animation in node.Animations) + { + //if (nodes.Count > 1) + // animation.Name += i.ToString("d2", CultureInfo.InvariantCulture); + + if ((animation.Flags & ObjectAnimationFlags.Local) == 0) + { + //animation.Scale = Matrix.CreateScale(setup.Scale); + + foreach (var key in animation.Keys) + { + key.Rotation = setup.Orientation * key.Rotation; + key.Translation += setup.Position; + } + } + + if ((animation.Flags & ObjectAnimationFlags.AutoStart) != 0) + { + setup.Animation = animation; + setup.PhysicsType = ObjectPhysicsType.Animated; + } + + var writer = new DatWriter(); + writer.BeginImport(); + ObjectDatWriter.WriteAnimation(animation, writer); + writer.Write(outputDirPath); + } + + if (setup.Animation == null && node.Animations.Length > 0) + { + setup.Animation = node.Animations[0]; + } + + if (setup.Animation != null) + { + var frame0 = setup.Animation.Keys[0]; + + setup.Scale = frame0.Scale.X; + setup.Orientation = frame0.Rotation; + setup.Position = frame0.Translation; + } + + level.physics.Add(setup); + } + } + } + + private void ImportModel(string basePath) + { + info.WriteLine("Importing objects..."); + ImportGunkObjects(); + + info.WriteLine("Importing textures..."); + ImportModelTextures(); + + info.WriteLine("Generating grids..."); + + string gridFilePath = Path.Combine(basePath, string.Format("temp/grids/{0}_grids.dae", level.name)); + + var gridBuilder = new RoomGridBuilder(roomScenes[0], model); + gridBuilder.Build(); + AkiraDaeWriter.WriteRooms(gridBuilder.Mesh, gridFilePath); + + daeReader.ReadScene(Dae.Reader.ReadFile(gridFilePath), new Dictionary()); + + info.WriteLine("Writing environment..."); + + var writer = new DatWriter(); + AkiraDatWriter.Write(model, writer, level.name, debug); + writer.Write(outputDirPath); + } + + private void ImportGunkNode(int gunkId, Matrix transform, GunkFlags flags, Geometry geometry) + { + ImportGunk(gunkId, transform, flags, geometry, null); + } + + private void ImportGunk(int gunkId, Matrix transform, GunkFlags flags, Geometry geometry, string textureName) + { + TextureFormat? textureFormat = null; + + if (geometry.Texture != null) + { + Texture texture = null; + + if (!geometry.Texture.IsPlaceholder) + { + texture = TextureDatReader.ReadInfo(geometry.Texture); + } + else + { + var txmp = FindSharedInstance(TemplateTag.TXMP, geometry.Texture.Name); + + if (txmp != null) + texture = TextureDatReader.ReadInfo(txmp); + } + + if (texture != null) + textureFormat = texture.Format; + } + else + { + if (geometry.TextureName != null) + { + var options = textureImporter.GetOptions(geometry.TextureName, false); + + if (options != null) + textureFormat = options.Format; + } + } + + switch (textureFormat) + { + case TextureFormat.BGRA4444: + case TextureFormat.BGRA5551: + case TextureFormat.RGBA: + flags |= GunkFlags.Transparent | GunkFlags.TwoSided | GunkFlags.NoOcclusion; + break; + } + + Material material; + + if (!string.IsNullOrEmpty(textureName)) + material = model.Materials.GetMaterial(textureName); + else if (!string.IsNullOrEmpty(geometry.TextureName)) + material = model.Materials.GetMaterial(geometry.TextureName); + else if (geometry.Texture != null) + material = model.Materials.GetMaterial(geometry.Texture.Name); + else + material = model.Materials.GetMaterial("NONE"); + + int pointIndexBase = model.Points.Count; + int texCoordIndexBase = model.TexCoords.Count; + + model.Points.AddRange(Vector3.Transform(geometry.Points, ref transform)); + model.TexCoords.AddRange(geometry.TexCoords); + + foreach (var quad in Quadify.Do(geometry)) + { + var pointIndices = new int[quad.Length]; + var texCoordIndices = new int[quad.Length]; + var colors = new Imaging.Color[quad.Length]; + + for (int j = 0; j < quad.Length; j++) + { + pointIndices[j] = pointIndexBase + quad[j]; + texCoordIndices[j] = texCoordIndexBase + quad[j]; + colors[j] = new Imaging.Color(207, 207, 207); + } + + var poly = new Polygon(model, pointIndices) { + TexCoordIndices = texCoordIndices, + Colors = colors, + Material = material, + ObjectId = gunkId & 0xffffff, + ObjectType = gunkId >> 24 + }; + + poly.Flags |= flags; + model.Polygons.Add(poly); + } + } + + private void ImportModelTextures() + { + int imported = 0; + int copied = 0; + + var copy = new List(); + + foreach (var material in model.Polygons.Select(p => p.Material).Distinct()) + { + //if (material.IsMarker) + // continue; + + if (File.Exists(material.ImageFilePath)) + { + var options = textureImporter.AddMaterial(material); + + if (options != null) + material.Flags |= options.GunkFlags; + + imported++; + } + else + { + var txmp = FindSharedInstance(TemplateTag.TXMP, material.Name); + + if (txmp != null) + copy.Add(txmp); + } + } + + Parallel.ForEach(copy, txmp => { + var texture = TextureDatReader.Read(txmp); + + if ((texture.Flags & TextureFlags.HasMipMaps) == 0) + { + texture.GenerateMipMaps(); + TextureDatWriter.Write(texture, outputDirPath); + System.Threading.Interlocked.Increment(ref imported); + } + else + { + string sourceFilePath = txmp.File.FilePath; + File.Copy(sourceFilePath, Path.Combine(outputDirPath, Path.GetFileName(sourceFilePath)), true); + System.Threading.Interlocked.Increment(ref copied); + } + }); + + error.WriteLine("Imported {0} textures, copied {1} textures", imported, copied); + } + + private ObjectAnimationClip ReadAnimationClip(XmlReader xml) + { + var anim = new ObjectAnimationClip(xml.GetAttribute("Name")); + + if (!xml.SkipEmpty()) + { + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "Start": + anim.Start = xml.ReadElementContentAsInt(); + break; + case "Stop": + anim.Stop = xml.ReadElementContentAsInt(); + break; + case "End": + anim.End = xml.ReadElementContentAsInt(); + break; + case "Flags": + anim.Flags = xml.ReadElementContentAsEnum(); + break; + default: + error.WriteLine("Unknown object animation parameter {0}", xml.LocalName); + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + } + + return anim; + } + } +} Index: /OniSplit/Level/ObjectImporter.cs =================================================================== --- /OniSplit/Level/ObjectImporter.cs (revision 1114) +++ /OniSplit/Level/ObjectImporter.cs (revision 1114) @@ -0,0 +1,473 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml; +using Oni.Xml; + +namespace Oni.Level +{ + using Akira; + using Motoko; + using Objects; + using Physics; + + partial class LevelImporter + { + private List objects; + private ObjectLoadContext objectLoadContext; + + private void ReadObjects(XmlReader xml, string basePath) + { + info.WriteLine("Reading objects..."); + + objects = new List(); + objectLoadContext = new ObjectLoadContext(FindSharedInstance, info); + + xml.ReadStartElement("Objects"); + + while (xml.IsStartElement()) + ReadObjectFile(Path.Combine(basePath, xml.ReadElementContentAsString("Import", ""))); + + xml.ReadEndElement(); + } + + private void ReadObjectFile(string filePath) + { + var basePath = Path.GetDirectoryName(filePath); + + objectLoadContext.BasePath = basePath; + objectLoadContext.FilePath = filePath; + + var settings = new XmlReaderSettings { + IgnoreWhitespace = true, + IgnoreProcessingInstructions = true, + IgnoreComments = true + }; + + using (var xml = XmlReader.Create(filePath, settings)) + { + xml.ReadStartElement("Oni"); + + switch (xml.LocalName) + { + case "Objects": + objects.AddRange(ReadObjects(xml)); + break; + + case "Particles": + level.particles.AddRange(ReadParticles(xml, basePath)); + break; + + case "Characters": + level.characters.AddRange(ReadCharacters(xml, basePath)); + break; + + case "Physics": + ReadPhysics(xml, basePath); + break; + + case "Corpses": + case "CRSA": + level.corpses.AddRange(ReadCorpses(xml, basePath)); + break; + + default: + error.WriteLine("Unknown object file type {0}", xml.LocalName); + xml.Skip(); + break; + } + + xml.ReadEndElement(); + } + } + + private IEnumerable ReadObjects(XmlReader xml) + { + if (xml.SkipEmpty()) + yield break; + + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + ObjectBase obj; + + switch (xml.LocalName) + { + case "CHAR": + case "Character": + obj = new Character(); + break; + case "WEAP": + case "Weapon": + obj = new Weapon(); + break; + case "PART": + case "Particle": + obj = new Particle(); + break; + case "PWRU": + case "PowerUp": + obj = new PowerUp(); + break; + case "FLAG": + case "Flag": + obj = new Flag(); + break; + case "DOOR": + case "Door": + obj = new Door(); + break; + case "CONS": + case "Console": + obj = new Console(); + break; + case "FURN": + case "Furniture": + obj = new Furniture(); + break; + case "TURR": + case "Turret": + obj = new Turret(); + break; + case "SNDG": + case "Sound": + obj = new Sound(); + break; + case "TRIG": + case "Trigger": + obj = new Trigger(); + break; + case "TRGV": + case "TriggerVolume": + obj = new TriggerVolume(); + break; + case "NEUT": + case "Neutral": + obj = new Neutral(); + break; + case "PATR": + case "Patrol": + obj = new PatrolPath(); + break; + default: + error.WriteLine("Unknonw object type {0}", xml.LocalName); + xml.Skip(); + continue; + } + + obj.Read(xml, objectLoadContext); + + var gunkObject = obj as GunkObject; + + if (gunkObject != null && gunkObject.GunkClass == null) + continue; + + yield return obj; + } + + xml.ReadEndElement(); + } + + private void ImportGunkObjects() + { + int nextObjectId = 1; + + foreach (var obj in objects) + { + obj.ObjectId = nextObjectId++; + + if (obj is Door) + ImportDoor((Door)obj); + else if (obj is Furniture) + ImportFurniture((Furniture)obj); + else if (obj is GunkObject) + ImportGunkObject((GunkObject)obj, GunkFlags.NoOcclusion); + } + } + + private void ImportFurniture(Furniture furniture) + { + ImportGunkObject(furniture, GunkFlags.NoOcclusion | GunkFlags.Furniture); + + foreach (var particle in furniture.Class.Geometry.Particles) + ImportParticle(furniture.ParticleTag, furniture.Transform, particle); + } + + private void ImportGunkObject(GunkObject gunkObject, GunkFlags flags) + { + foreach (var node in gunkObject.GunkClass.GunkNodes) + ImportGunkNode(gunkObject.GunkId, gunkObject.Transform, node.Flags | flags, node.Geometry); + } + + private void ImportDoor(Door door) + { + var placement = door.Transform; + + float minY = 0.0f; + float minX = 0.0f; + float maxX = 0.0f; + + var geometryTransform = Matrix.CreateScale(door.Class.Animation.Keys[0].Scale) * Matrix.CreateRotationX(-MathHelper.HalfPi); + + foreach (var node in door.Class.GunkNodes) + { + var bbox = BoundingBox.CreateFromPoints(Vector3.Transform(node.Geometry.Points, ref geometryTransform)); + + minY = Math.Min(minY, bbox.Min.Y); + minX = Math.Min(minX, bbox.Min.X); + maxX = Math.Max(maxX, bbox.Max.X); + } + + placement.Translation -= Vector3.UnitY * minY; + + float xOffset; + int sides; + + if ((door.Flags & DoorFlags.DoubleDoor) == 0) + { + xOffset = 0.0f; + sides = 1; + } + else + { + xOffset = (maxX - minX) / 2.0f; + sides = 2; + } + + for (int side = 0; side < sides; side++) + { + Matrix origin, gunkTransform; + + if (side == 0) + { + var m1 = Matrix.CreateTranslation(xOffset, 0.0f, 0.0f) * placement; + origin = geometryTransform * m1; + gunkTransform = origin; + } + else + { + var m2 = Matrix.CreateTranslation(-xOffset, 0.0f, 0.0f) * placement; + origin = Matrix.CreateRotationY(MathHelper.Pi) * geometryTransform * m2; + gunkTransform = geometryTransform * Matrix.CreateRotationY(MathHelper.Pi) * m2; + } + + var scriptId = door.ScriptId | (side << 12); + var geometries = ImportDoorGeometry(door, side); + + level.physics.Add(new ObjectSetup { + Name = string.Format("door_{0}", scriptId), + Flags = ObjectSetupFlags.FaceCollision, + DoorScriptId = scriptId, + Origin = origin, + Geometries = geometries + }); + + foreach (var geometry in geometries) + ImportGunkNode(door.GunkId, gunkTransform, GunkFlags.NoDecals | GunkFlags.NoCollision, geometry); + } + } + + private Geometry[] ImportDoorGeometry(Door door, int side) + { + InstanceDescriptor overrideTexture = null; + + if (!string.IsNullOrEmpty(door.Textures[side])) + overrideTexture = FindSharedInstance(TemplateTag.TXMP, door.Textures[side]); + + var nodes = door.Class.Geometry.Geometries; + var geometries = new Geometry[nodes.Length]; + + for (int i = 0; i < nodes.Length; i++) + { + var node = nodes[i]; + + var geometry = new Geometry { + Points = node.Geometry.Points, + TexCoords = node.Geometry.TexCoords, + Normals = node.Geometry.Normals, + Triangles = node.Geometry.Triangles + }; + + if (overrideTexture != null) + { + geometry.Texture = overrideTexture; + geometry.TextureName = overrideTexture.Name; + } + else if (node.Geometry.Texture != null) + { + geometry.TextureName = node.Geometry.Texture.Name; + } + + geometries[i] = geometry; + } + + return geometries; + } + + private void WriteObjects() + { + ObjcDatWriter.Write(objects, outputDirPath); + } + + private IEnumerable ReadCorpses(XmlReader xml, string basePath) + { + var fileName = Path.GetFileName(objectLoadContext.FilePath); + + var isOldFormat = xml.IsStartElement("CRSA"); + int readCount = 0, fixedCount = 0, usedCount = 0; + + if (isOldFormat) + { + xml.ReadStartElement("CRSA"); + + if (xml.IsStartElement("FixedCount")) + fixedCount = xml.ReadElementContentAsInt("FixedCount", ""); + + if (xml.IsStartElement("UsedCount")) + usedCount = xml.ReadElementContentAsInt("UsedCount", ""); + + if (usedCount < fixedCount) + { + error.WriteLine("There are more fixed corpses ({0}) than used corpses ({1}) - assuming fixed = used", fixedCount, usedCount); + fixedCount = usedCount; + } + } + + xml.ReadStartElement("Corpses"); + + while (xml.IsStartElement()) + { + var corpse = new Corpse(); + corpse.IsFixed = isOldFormat && readCount < fixedCount; + corpse.IsUsed = !isOldFormat || readCount < usedCount; + corpse.FileName = fileName; + + if (xml.IsEmptyElement) + { + corpse.IsUsed = false; + } + + if (!corpse.IsUsed) + { + xml.Skip(); + } + else if (xml.LocalName == "Corpse" || xml.LocalName == "CRSACorpse") + { + xml.ReadStartElement(); + + if (!isOldFormat) + { + if (xml.IsStartElement("CanDelete")) + { + corpse.IsFixed = false; + xml.Skip(); + } + else + { + corpse.IsFixed = true; + } + } + + if (xml.IsStartElement("Class") || xml.IsStartElement("CharacterClass")) + corpse.CharacterClass = xml.ReadElementContentAsString(); + + if (string.IsNullOrEmpty(corpse.CharacterClass)) + { + corpse.IsUsed = false; + corpse.IsFixed = false; + } + + xml.ReadStartElement("Transforms"); + + for (int j = 0; j < corpse.Transforms.Length; j++) + { + if (xml.IsStartElement("Matrix4x3")) + corpse.Transforms[j] = xml.ReadElementContentAsMatrix43("Matrix4x3"); + else if (xml.IsStartElement("Matrix")) + corpse.Transforms[j] = xml.ReadElementContentAsMatrix43("Matrix"); + } + + xml.ReadEndElement(); + + if (xml.IsStartElement("BoundingBox")) + { + xml.ReadStartElement("BoundingBox"); + corpse.BoundingBox.Min = xml.ReadElementContentAsVector3("Min"); + corpse.BoundingBox.Max = xml.ReadElementContentAsVector3("Max"); + xml.ReadEndElement(); + } + else + { + corpse.BoundingBox.Min = corpse.Transforms[0].Translation; + corpse.BoundingBox.Max = corpse.Transforms[0].Translation; + corpse.BoundingBox.Inflate(new Vector3(10.0f, 5.0f, 10.0f)); + } + + xml.ReadEndElement(); + } + else + { + var filePath = xml.ReadElementContentAsString("Import", ""); + filePath = Path.Combine(basePath, filePath); + + using (var reader = new BinaryReader(filePath)) + { + corpse.FileName = Path.GetFileName(filePath); + corpse.IsUsed = true; + corpse.IsFixed = true; + + corpse.CharacterClass = reader.ReadString(128); + reader.Skip(4); + + for (int i = 0; i < corpse.Transforms.Length; i++) + corpse.Transforms[i] = reader.ReadMatrix4x3(); + + corpse.BoundingBox = reader.ReadBoundingBox(); + } + } + + readCount++; + yield return corpse; + } + + if (readCount < usedCount) + { + error.WriteLine("{0} corpses were expected but only {1} have been read", usedCount, readCount); + } + + info.WriteLine("Read {0} corpses", readCount); + } + + private InstanceFileManager fileManager; + + private InstanceDescriptor FindSharedInstance(TemplateTag tag, string name, ObjectLoadContext loadContext) + { + if (!name.EndsWith(".oni", StringComparison.OrdinalIgnoreCase)) + return FindSharedInstance(tag, name); + + string filePath = Path.GetFullPath(Path.Combine(loadContext.BasePath, name)); + + if (File.Exists(filePath)) + { + if (fileManager == null) + fileManager = new InstanceFileManager(); + + return fileManager.OpenFile(filePath).Descriptors[0]; + } + + filePath = Path.GetFullPath(Path.Combine(sharedPath, name)); + + if (File.Exists(filePath)) + { + var file = sharedManager.OpenFile(filePath); + + return file.Descriptors[0]; + } + + error.WriteLine("Could not find {0}", name); + + return null; + } + } +} Index: /OniSplit/Level/ParticleImporter.cs =================================================================== --- /OniSplit/Level/ParticleImporter.cs (revision 1114) +++ /OniSplit/Level/ParticleImporter.cs (revision 1114) @@ -0,0 +1,35 @@ +using System; +using System.Collections.Generic; +using System.Xml; + +namespace Oni.Level +{ + using Oni.Physics; + + partial class LevelImporter + { + private static IEnumerable ReadParticles(XmlReader xml, string basePath) + { + if (xml.SkipEmpty()) + yield break; + + xml.ReadStartElement(); + + while (xml.IsStartElement()) + yield return ObjectXmlReader.ReadParticle(xml); + + xml.ReadEndElement(); + } + + private void ImportParticle(string tag, Matrix matrix, ObjectParticle particle) + { + level.particles.Add(new ObjectParticle { + ParticleClass = particle.ParticleClass, + Tag = tag + "_" + particle.Tag, + Matrix = particle.Matrix * matrix, + DecalScale = particle.DecalScale, + Flags = particle.Flags + }); + } + } +} Index: /OniSplit/Level/PhysicsImporter.cs =================================================================== --- /OniSplit/Level/PhysicsImporter.cs (revision 1114) +++ /OniSplit/Level/PhysicsImporter.cs (revision 1114) @@ -0,0 +1,245 @@ +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Xml; + +namespace Oni.Level +{ + using Akira; + using Metadata; + using Motoko; + using Physics; + using Xml; + + partial class LevelImporter + { + private void ReadPhysics(XmlReader xml, string basePath) + { + if (xml.SkipEmpty()) + return; + + xml.ReadStartElement("Physics"); + + while (xml.IsStartElement()) + ReadObjectSetup(xml, basePath); + + xml.ReadEndElement(); + } + + private void ReadObjectSetup(XmlReader xml, string basePath) + { + var scriptId = -1; + var name = xml.GetAttribute("Name"); + var position = Vector3.Zero; + var rotation = Quaternion.Identity; + var scale = 1.0f; + var flags = ObjectSetupFlags.None; + var physicsType = ObjectPhysicsType.None; + var particles = new List(); + var nodes = new List(); + string geometryName = null; + string animationName = null; + + xml.ReadStartElement("Object"); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "Name": + name = xml.ReadElementContentAsString(); + break; + case "ScriptId": + scriptId = xml.ReadElementContentAsInt(); + break; + case "Flags": + flags = xml.ReadElementContentAsEnum() & ~ObjectSetupFlags.InUse; + break; + case "Position": + position = xml.ReadElementContentAsVector3(); + break; + case "Rotation": + rotation = xml.ReadElementContentAsEulerXYZ(); + break; + case "Scale": + scale = xml.ReadElementContentAsFloat(); + break; + case "Physics": + physicsType = xml.ReadElementContentAsEnum(); + break; + case "Particles": + particles.AddRange(ReadParticles(xml, basePath)); + break; + + case "Geometry": + geometryName = xml.ReadElementContentAsString(); + if (nodes.Count > 0) + { + error.WriteLine("Geometry cannot be used together with Import, ignoring"); + break; + } + break; + + case "Animation": + animationName = xml.ReadElementContentAsString(); + if (nodes.Count > 0) + { + error.WriteLine("Animation cannot be used together with Import, ignoring"); + break; + } + break; + + case "Import": + if (geometryName != null || animationName != null) + { + error.WriteLine("Import cannot be used together with Geometry and Animation, ignoring"); + break; + } + nodes.AddRange(ImportObjectGeometry(xml, basePath)); + break; + + default: + error.WriteLine("Unknown physics object element {0}", xml.LocalName); + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + + if (geometryName != null) + { + var m3gm = FindSharedInstance(TemplateTag.M3GM, geometryName, objectLoadContext); + var geometry = GeometryDatReader.Read(m3gm); + var animation = new ObjectAnimation[0]; + + if (animationName != null) + { + var oban = FindSharedInstance(TemplateTag.OBAN, animationName, objectLoadContext); + animation = new[] { ObjectDatReader.ReadAnimation(oban) }; + } + + nodes.Add(new ObjectNode(new[] { new ObjectGeometry(geometry) }) { + FileName = Path.GetFileName(geometryName), + Name = m3gm.Name, + ScriptId = scriptId, + Flags = flags, + Animations = animation + }); + } + + for (int i = 0; i < nodes.Count; i++) + { + var node = nodes[i]; + + var setup = new ObjectSetup { + Name = node.Name, + FileName = node.FileName, + ScriptId = scriptId++, + Flags = flags, + PhysicsType = physicsType, + }; + + setup.Particles.AddRange(particles); + + setup.Geometries = node.Geometries + .Where(n => (n.Flags & GunkFlags.Invisible) == 0) + .Select(n => n.Geometry.Name).ToArray(); + + foreach (var nodeGeometry in node.Geometries.Where(g => (g.Flags & GunkFlags.Invisible) == 0)) + { + var writer = new DatWriter(); + GeometryDatWriter.Write(nodeGeometry.Geometry, writer.ImporterFile); + writer.Write(outputDirPath); + } + + setup.Position = position; + setup.Orientation = rotation; + setup.Scale = scale; + setup.Origin = Matrix.CreateFromQuaternion(setup.Orientation) + * Matrix.CreateScale(setup.Scale) + * Matrix.CreateTranslation(setup.Position); + + foreach (var animation in node.Animations) + { + if (nodes.Count > 1) + animation.Name += i.ToString("d2", CultureInfo.InvariantCulture); + + if ((animation.Flags & ObjectAnimationFlags.Local) != 0) + { + //animation.Scale = Matrix.CreateScale(setup.Scale); + + foreach (var key in animation.Keys) + { + key.Rotation = setup.Orientation * key.Rotation; + key.Translation += setup.Position; + } + } + + if ((animation.Flags & ObjectAnimationFlags.AutoStart) != 0) + { + setup.Animation = animation; + setup.PhysicsType = ObjectPhysicsType.Animated; + } + + var writer = new DatWriter(); + ObjectDatWriter.WriteAnimation(animation, writer); + writer.Write(outputDirPath); + } + + if (setup.Animation == null && node.Animations.Length > 0) + { + setup.Animation = node.Animations[0]; + } + + if (setup.Animation != null) + { + var frame0 = setup.Animation.Keys[0]; + + setup.Scale = frame0.Scale.X; + setup.Orientation = frame0.Rotation; + setup.Position = frame0.Translation; + } + + level.physics.Add(setup); + } + } + + private IEnumerable ImportObjectGeometry(XmlReader xml, string basePath) + { + var filePath = xml.GetAttribute("Path"); + + if (filePath == null) + filePath = xml.GetAttribute("Url"); + + var scene = LoadScene(Path.Combine(basePath, filePath)); + var animClips = new List(); + + if (!xml.SkipEmpty()) + { + xml.ReadStartElement(); + + while (xml.IsStartElement()) + { + switch (xml.LocalName) + { + case "Animation": + animClips.Add(ReadAnimationClip(xml)); + break; + + default: + error.WriteLine("Unknown element {0}", xml.LocalName); + xml.Skip(); + break; + } + } + + xml.ReadEndElement(); + } + + var importer = new ObjectDaeImporter(textureImporter, null); + importer.Import(scene); + return importer.Nodes; + } + } +} Index: /OniSplit/Level/ScriptCharacter.cs =================================================================== --- /OniSplit/Level/ScriptCharacter.cs (revision 1114) +++ /OniSplit/Level/ScriptCharacter.cs (revision 1114) @@ -0,0 +1,58 @@ +using System; +using System.Xml; +using Oni.Metadata; + +namespace Oni.Level +{ + internal class ScriptCharacter + { + public string className; + public string name; + public string weaponClassName; + public int flagId; + public int scriptId; + public InstanceMetadata.AISACharacterFlags flags; + public InstanceMetadata.AISACharacterTeam team; + public string onSpawn; + public string onDeath; + public string onSeenEnemy; + public string onAlarmed; + public string onHurt; + public string onDefeated; + public string onOutOfAmmo; + public string onNoPath; + public int ammo; + + public static ScriptCharacter Read(XmlReader xml) + { + xml.ReadStartElement("Character"); + + var chr = new ScriptCharacter { + name = xml.ReadElementContentAsString("Name", ""), + scriptId = xml.ReadElementContentAsInt("ScriptId", ""), + flagId = xml.ReadElementContentAsInt("FlagId", ""), + flags = xml.ReadElementContentAsEnum("Flags"), + team = xml.ReadElementContentAsEnum("Team"), + className = xml.ReadElementContentAsString("Class", "") + }; + + xml.ReadStartElement("Scripts"); + chr.onSpawn = xml.ReadElementContentAsString("Spawn", ""); + chr.onDeath = xml.ReadElementContentAsString("Die", ""); + chr.onSeenEnemy = xml.ReadElementContentAsString("Combat", ""); + chr.onAlarmed = xml.ReadElementContentAsString("Alarm", ""); + chr.onHurt = xml.ReadElementContentAsString("Hurt", ""); + chr.onDefeated = xml.ReadElementContentAsString("Defeated", ""); + chr.onOutOfAmmo = xml.ReadElementContentAsString("OutOfAmmo", ""); + chr.onNoPath = xml.ReadElementContentAsString("NoPath", ""); + xml.ReadEndElement(); + + chr.weaponClassName = xml.ReadElementContentAsString("Weapon", ""); + chr.ammo = xml.ReadElementContentAsInt("Ammo", ""); + + xml.ReadEndElement(); + + return chr; + } + } +} Index: /OniSplit/Level/SkyImporter.cs =================================================================== --- /OniSplit/Level/SkyImporter.cs (revision 1114) +++ /OniSplit/Level/SkyImporter.cs (revision 1114) @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Xml; + +namespace Oni.Level +{ + partial class LevelImporter + { + private void ReadSky(XmlReader xml, string basePath) + { + level.skyName = xml.ReadElementContentAsString("Sky", ""); + } + } +} Index: /OniSplit/Level/TextureImporter.cs =================================================================== --- /OniSplit/Level/TextureImporter.cs (revision 1114) +++ /OniSplit/Level/TextureImporter.cs (revision 1114) @@ -0,0 +1,68 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml; + +namespace Oni.Level +{ + using Oni.Akira; + using Oni.Metadata; + using Oni.Motoko; + using Oni.Xml; + + partial class LevelImporter + { + private Motoko.TextureImporter3 textureImporter; + private TextureFormat defaultTextureFormat = TextureFormat.BGR; + private TextureFormat defaultAlphaTextureFormat = TextureFormat.RGBA; + private int maxTextureSize = 512; + + private void ReadTextures(XmlReader xml, string basePath) + { + if (xml.SkipEmpty()) + return; + + string format = xml.GetAttribute("Format"); + string alphaFormat = xml.GetAttribute("AlphaFormat"); + string size = xml.GetAttribute("MaxSize"); + + if (format != null) + defaultTextureFormat = TextureImporter.ParseTextureFormat(format); + + if (alphaFormat != null) + defaultAlphaTextureFormat = TextureImporter.ParseTextureFormat(alphaFormat); + + if (size != null) + maxTextureSize = int.Parse(size); + + xml.ReadStartElement("Textures"); + + while (xml.IsStartElement()) + { + if (xml.LocalName == "Import") + { + var importPath = Path.Combine(basePath, xml.ReadElementContentAsString()); + + var settings = new XmlReaderSettings { + IgnoreWhitespace = true, + IgnoreProcessingInstructions = true, + IgnoreComments = true + }; + + using (var importXml = XmlReader.Create(importPath, settings)) + { + importXml.ReadStartElement("Oni"); + ReadTextures(importXml, Path.GetDirectoryName(importPath)); + importXml.ReadEndElement(); + } + } + else + { + textureImporter.ReadOptions(xml, basePath); + } + } + + xml.ReadEndElement(); + } + } +} Index: /OniSplit/Math/BoundingBox.cs =================================================================== --- /OniSplit/Math/BoundingBox.cs (revision 1114) +++ /OniSplit/Math/BoundingBox.cs (revision 1114) @@ -0,0 +1,112 @@ +using System; +using System.Collections.Generic; + +namespace Oni +{ + internal struct BoundingBox : IEquatable + { + public Vector3 Min; + public Vector3 Max; + + public BoundingBox(Vector3 min, Vector3 max) + { + Min = min; + Max = max; + } + + public static BoundingBox CreateFromSphere(BoundingSphere sphere) + { + var radius = new Vector3(sphere.Radius); + + return new BoundingBox(sphere.Center - radius, sphere.Center + radius); + } + + public static BoundingBox CreateFromPoints(IEnumerable points) + { + var min = new Vector3(float.MaxValue); + var max = new Vector3(float.MinValue); + + foreach (var point in points) + { + var p = point; + + Vector3.Min(ref min, ref p, out min); + Vector3.Max(ref max, ref p, out max); + } + + return new BoundingBox(min, max); + } + + public bool Contains(Vector3 point) => + point.X >= Min.X && point.X <= Max.X + && point.Y >= Min.Y && point.Y <= Max.Y + && point.Z >= Min.Z && point.Z <= Max.Z; + + public bool Contains(BoundingBox box) => + Min.X <= box.Min.X && box.Max.X <= Max.X + && Min.Y <= box.Min.Y && box.Max.Y <= Max.Y + && Min.Z <= box.Min.Z && box.Max.Z <= Max.Z; + + public bool Intersects(BoundingBox box) => + Max.X >= box.Min.X && Min.X <= box.Max.X + && Max.Y >= box.Min.Y && Min.Y <= box.Max.Y + && Max.Z >= box.Min.Z && Min.Z <= box.Max.Z; + + public bool Intersects(Plane plane) + { + Vector3 v0, v1; + + v0.X = (plane.Normal.X >= 0.0f) ? Max.X : Min.X; + v1.X = (plane.Normal.X >= 0.0f) ? Min.X : Max.X; + + v0.Y = (plane.Normal.Y >= 0.0f) ? Max.Y : Min.Y; + v1.Y = (plane.Normal.Y >= 0.0f) ? Min.Y : Max.Y; + + v0.Z = (plane.Normal.Z >= 0.0f) ? Max.Z : Min.Z; + v1.Z = (plane.Normal.Z >= 0.0f) ? Min.Z : Max.Z; + + return plane.Normal.Dot(ref v1) <= -plane.D + && plane.Normal.Dot(ref v0) >= -plane.D; + } + + public Vector3[] GetCorners() => new[] + { + new Vector3(Min.X, Max.Y, Max.Z), + new Vector3(Max.X, Max.Y, Max.Z), + new Vector3(Max.X, Min.Y, Max.Z), + new Vector3(Min.X, Min.Y, Max.Z), + new Vector3(Min.X, Max.Y, Min.Z), + new Vector3(Max.X, Max.Y, Min.Z), + new Vector3(Max.X, Min.Y, Min.Z), + new Vector3(Min.X, Min.Y, Min.Z) + }; + + public static bool operator ==(BoundingBox b1, BoundingBox b2) => b1.Min == b2.Min && b1.Max == b2.Max; + public static bool operator !=(BoundingBox b1, BoundingBox b2) => b1.Min != b2.Min || b1.Max != b2.Max; + + public bool Equals(BoundingBox other) => Min == other.Min && Max == other.Max; + + public override bool Equals(object obj) => obj is BoundingBox && Equals((BoundingBox)obj); + public override int GetHashCode() => Min.GetHashCode() ^ Max.GetHashCode(); + + public override string ToString() => $"{{{Min} {Max}}}"; + + public float Volume() + { + Vector3 size = Max - Min; + return size.X * size.Y * size.Z; + } + + public void Inflate(Vector3 v) + { + Min -= v; + Max += v; + } + + public float Height => Max.Y - Min.Y; + public float Width => Max.X - Min.X; + public float Depth => Max.Z - Min.Z; + + public Vector3 Size => Max - Min; + } +} Index: /OniSplit/Math/BoundingSphere.cs =================================================================== --- /OniSplit/Math/BoundingSphere.cs (revision 1114) +++ /OniSplit/Math/BoundingSphere.cs (revision 1114) @@ -0,0 +1,63 @@ +using System; +using System.Collections.Generic; + +namespace Oni +{ + internal struct BoundingSphere : IEquatable + { + public Vector3 Center; + public float Radius; + + public BoundingSphere(Vector3 center, float radius) + { + Center = center; + Radius = radius; + } + + public static BoundingSphere CreateFromBoundingBox(BoundingBox bbox) + { + BoundingSphere r; + r.Center = (bbox.Min + bbox.Max) * 0.5f; + r.Radius = Vector3.Distance(r.Center, bbox.Min); + return r; + } + + public static BoundingSphere CreateFromPoints(IEnumerable points) + { + var center = Vector3.Zero; + int count = 0; + + foreach (var point in points) + { + center += point; + count++; + } + + center /= count; + + float radius = 0.0f; + + foreach (var point in points) + { + float distance = Vector3.DistanceSquared(center, point); + + if (distance > radius) + radius = distance; + } + + radius = FMath.Sqrt(radius); + + return new BoundingSphere(center, radius); + } + + public static bool operator ==(BoundingSphere s1, BoundingSphere s2) => s1.Radius == s2.Radius && s1.Center == s2.Center; + public static bool operator !=(BoundingSphere s1, BoundingSphere s2) => s1.Radius != s2.Radius || s1.Center != s2.Center; + + public bool Equals(BoundingSphere other) => other.Radius == Radius && other.Center == Center; + + public override bool Equals(object obj) => obj is BoundingSphere && Equals((BoundingSphere)obj); + public override int GetHashCode() => Radius.GetHashCode() ^ Center.GetHashCode(); + + public override string ToString() => $"{{{Center} {Radius}}}"; + } +} Index: /OniSplit/Math/FMath.cs =================================================================== --- /OniSplit/Math/FMath.cs (revision 1114) +++ /OniSplit/Math/FMath.cs (revision 1114) @@ -0,0 +1,27 @@ +using System; + +namespace Oni +{ + internal static class FMath + { + public static float Sign(float x) + { + if (x > 0.0f) + return 1.0f; + else if (x < 0.0f) + return -1.0f; + else + return 0.0f; + } + + public static float Sqrt(float x) => (float)Math.Sqrt(x); + public static float Sqr(float x) => x * x; + public static float Atan2(float y, float x) => (float)Math.Atan2(y, x); + public static float Cos(float x) => (float)Math.Cos(x); + public static float Sin(float x) => (float)Math.Sin(x); + public static float Acos(float x) => (float)Math.Acos(x); + public static float Round(float x, int digits) => (float)Math.Round(x, digits); + public static int RoundToInt32(float f) => (int)Math.Round(f); + public static int TruncateToInt32(float f) => (int)Math.Truncate(f); + } +} Index: /OniSplit/Math/MathHelper.cs =================================================================== --- /OniSplit/Math/MathHelper.cs (revision 1114) +++ /OniSplit/Math/MathHelper.cs (revision 1114) @@ -0,0 +1,59 @@ +using System; + +namespace Oni +{ + internal static class MathHelper + { + public const float Eps = 1e-5f; + public const float Pi = 3.141593f; + public const float HalfPi = Pi / 2.0f; + public const float PiOver4 = Pi / 4.0f; + public const float TwoPi = 2.0f * Pi; + + public static float ToDegrees(float radians) => radians * (180.0f / Pi); + public static float ToRadians(float degrees) => degrees * (Pi / 180.0f); + public static float Distance(float v1, float v2) => Math.Abs(v2 - v1); + public static float Lerp(float v1, float v2, float amount) => v1 + (v2 - v1) * amount; + + public static int Lerp(int v1, int v2, float amount) + { + if (amount == 0.0f) + return v1; + + if (amount == 1.0f) + return v2; + + return (int)(v1 + (v2 - v1) * amount); + } + + public static float Clamp(float v, float min, float max) + { + v = (v > max) ? max : v; + v = (v < min) ? min : v; + + return v; + } + + public static int Clamp(int v, int min, int max) + { + v = (v > max) ? max : v; + v = (v < min) ? min : v; + + return v; + } + + public static float Area(Vector2[] points) + { + float area = 0.0f; + + for (int i = 0; i < points.Length; i++) + { + int j = (i + 1) % points.Length; + area += points[i].X * points[j].Y; + area -= points[i].Y * points[j].X; + } + + return Math.Abs(area * 0.5f); + } + } +} Index: /OniSplit/Math/Matrix.cs =================================================================== --- /OniSplit/Math/Matrix.cs (revision 1114) +++ /OniSplit/Math/Matrix.cs (revision 1114) @@ -0,0 +1,683 @@ +using System; + +namespace Oni +{ + internal struct Matrix : IEquatable + { + public float M11, M12, M13, M14; + public float M21, M22, M23, M24; + public float M31, M32, M33, M34; + public float M41, M42, M43, M44; + + public Matrix(float m11, float m12, float m13, float m14, + float m21, float m22, float m23, float m24, + float m31, float m32, float m33, float m34, + float m41, float m42, float m43, float m44) + { + M11 = m11; M12 = m12; M13 = m13; M14 = m14; + M21 = m21; M22 = m22; M23 = m23; M24 = m24; + M31 = m31; M32 = m32; M33 = m33; M34 = m34; + M41 = m41; M42 = m42; M43 = m43; M44 = m44; + } + + public Matrix(float[] values) + { + M11 = values[0]; M12 = values[4]; M13 = values[8]; M14 = values[12]; + M21 = values[1]; M22 = values[5]; M23 = values[9]; M24 = values[13]; + M31 = values[2]; M32 = values[6]; M33 = values[10]; M34 = values[14]; + M41 = values[3]; M42 = values[7]; M43 = values[11]; M44 = values[15]; + } + + public void CopyTo(float[] values) + { + values[0] = M11; + values[1] = M21; + values[2] = M31; + values[3] = M41; + + values[4] = M12; + values[5] = M22; + values[6] = M32; + values[7] = M42; + + values[8] = M13; + values[9] = M23; + values[10] = M33; + values[11] = M43; + + values[12] = M14; + values[13] = M24; + values[14] = M34; + values[15] = M44; + } + + public static Matrix CreateTranslation(float x, float y, float z) + { + Matrix r = Identity; + + r.M41 = x; + r.M42 = y; + r.M43 = z; + + return r; + } + + public static Matrix CreateTranslation(Vector3 v) => CreateTranslation(v.X, v.Y, v.Z); + + public static Matrix CreateScale(float sx, float sy, float sz) + { + Matrix r = Identity; + + r.M11 = sx; + r.M22 = sy; + r.M33 = sz; + + return r; + } + + public static Matrix CreateScale(float s) => CreateScale(s, s, s); + public static Matrix CreateScale(Vector3 s) => CreateScale(s.X, s.Y, s.Z); + + public static Matrix CreateRotationX(float angle) + { + float cos = FMath.Cos(angle); + float sin = FMath.Sin(angle); + + Matrix r = Identity; + r.M22 = cos; + r.M23 = sin; + r.M32 = -sin; + r.M33 = cos; + return r; + } + + public static Matrix CreateRotationY(float angle) + { + float cos = FMath.Cos(angle); + float sin = FMath.Sin(angle); + + Matrix r = Identity; + r.M11 = cos; + r.M13 = -sin; + r.M31 = sin; + r.M33 = cos; + return r; + } + + public static Matrix CreateRotationZ(float angle) + { + float cos = FMath.Cos(angle); + float sin = FMath.Sin(angle); + + Matrix r = Identity; + r.M11 = cos; + r.M12 = sin; + r.M21 = -sin; + r.M22 = cos; + return r; + } + + public static Matrix CreateFromAxisAngle(Vector3 axis, float angle) + { + float sin = FMath.Sin(angle); + float cos = FMath.Cos(angle); + + float x = axis.X; + float y = axis.Y; + float z = axis.Z; + float xx = x * x; + float yy = y * y; + float zz = z * z; + float xy = x * y; + float xz = x * z; + float yz = y * z; + + Matrix r = Identity; + r.M11 = xx + (cos * (1.0f - xx)); + r.M12 = (xy - (cos * xy)) + (sin * z); + r.M13 = (xz - (cos * xz)) - (sin * y); + r.M21 = (xy - (cos * xy)) - (sin * z); + r.M22 = yy + (cos * (1.0f - yy)); + r.M23 = (yz - (cos * yz)) + (sin * x); + r.M31 = (xz - (cos * xz)) + (sin * y); + r.M32 = (yz - (cos * yz)) - (sin * x); + r.M33 = zz + (cos * (1.0f - zz)); + return r; + } + + public static Matrix CreateFromQuaternion(Quaternion q) + { + float xx = q.X * q.X; + float yy = q.Y * q.Y; + float zz = q.Z * q.Z; + float xy = q.X * q.Y; + float zw = q.Z * q.W; + float zx = q.Z * q.X; + float yw = q.Y * q.W; + float yz = q.Y * q.Z; + float xw = q.X * q.W; + + Matrix r = Identity; + + r.M11 = 1.0f - 2.0f * (yy + zz); + r.M12 = 2.0f * (xy + zw); + r.M13 = 2.0f * (zx - yw); + + r.M21 = 2.0f * (xy - zw); + r.M22 = 1.0f - 2.0f * (zz + xx); + r.M23 = 2.0f * (yz + xw); + + r.M31 = 2.0f * (zx + yw); + r.M32 = 2.0f * (yz - xw); + r.M33 = 1.0f - 2.0f * (yy + xx); + + return r; + } + + public static Matrix operator +(Matrix m1, Matrix m2) + { + m1.M11 += m2.M11; + m1.M12 += m2.M12; + m1.M13 += m2.M13; + m1.M14 += m2.M14; + m1.M21 += m2.M21; + m1.M22 += m2.M22; + m1.M23 += m2.M23; + m1.M24 += m2.M24; + m1.M31 += m2.M31; + m1.M32 += m2.M32; + m1.M33 += m2.M33; + m1.M34 += m2.M34; + m1.M41 += m2.M41; + m1.M42 += m2.M42; + m1.M43 += m2.M43; + m1.M44 += m2.M44; + + return m1; + } + + public static Matrix operator -(Matrix m1, Matrix m2) + { + m1.M11 -= m2.M11; + m1.M12 -= m2.M12; + m1.M13 -= m2.M13; + m1.M14 -= m2.M14; + m1.M21 -= m2.M21; + m1.M22 -= m2.M22; + m1.M23 -= m2.M23; + m1.M24 -= m2.M24; + m1.M31 -= m2.M31; + m1.M32 -= m2.M32; + m1.M33 -= m2.M33; + m1.M34 -= m2.M34; + m1.M41 -= m2.M41; + m1.M42 -= m2.M42; + m1.M43 -= m2.M43; + m1.M44 -= m2.M44; + + return m1; + } + + public static Matrix operator *(Matrix m, float s) + { + m.M11 *= s; + m.M12 *= s; + m.M13 *= s; + m.M14 *= s; + m.M21 *= s; + m.M22 *= s; + m.M23 *= s; + m.M24 *= s; + m.M31 *= s; + m.M32 *= s; + m.M33 *= s; + m.M34 *= s; + m.M41 *= s; + m.M42 *= s; + m.M43 *= s; + m.M44 *= s; + + return m; + } + + public static Matrix operator *(float s, Matrix m) => m * s; + + public static Matrix operator /(Matrix m, float s) => m * (1.0f / s); + + public static Matrix operator *(Matrix m1, Matrix m2) + { + Matrix r; + + r.M11 = m1.M11 * m2.M11 + m1.M12 * m2.M21 + m1.M13 * m2.M31 + m1.M14 * m2.M41; + r.M12 = m1.M11 * m2.M12 + m1.M12 * m2.M22 + m1.M13 * m2.M32 + m1.M14 * m2.M42; + r.M13 = m1.M11 * m2.M13 + m1.M12 * m2.M23 + m1.M13 * m2.M33 + m1.M14 * m2.M43; + r.M14 = m1.M11 * m2.M14 + m1.M12 * m2.M24 + m1.M13 * m2.M34 + m1.M14 * m2.M44; + r.M21 = m1.M21 * m2.M11 + m1.M22 * m2.M21 + m1.M23 * m2.M31 + m1.M24 * m2.M41; + r.M22 = m1.M21 * m2.M12 + m1.M22 * m2.M22 + m1.M23 * m2.M32 + m1.M24 * m2.M42; + r.M23 = m1.M21 * m2.M13 + m1.M22 * m2.M23 + m1.M23 * m2.M33 + m1.M24 * m2.M43; + r.M24 = m1.M21 * m2.M14 + m1.M22 * m2.M24 + m1.M23 * m2.M34 + m1.M24 * m2.M44; + r.M31 = m1.M31 * m2.M11 + m1.M32 * m2.M21 + m1.M33 * m2.M31 + m1.M34 * m2.M41; + r.M32 = m1.M31 * m2.M12 + m1.M32 * m2.M22 + m1.M33 * m2.M32 + m1.M34 * m2.M42; + r.M33 = m1.M31 * m2.M13 + m1.M32 * m2.M23 + m1.M33 * m2.M33 + m1.M34 * m2.M43; + r.M34 = m1.M31 * m2.M14 + m1.M32 * m2.M24 + m1.M33 * m2.M34 + m1.M34 * m2.M44; + r.M41 = m1.M41 * m2.M11 + m1.M42 * m2.M21 + m1.M43 * m2.M31 + m1.M44 * m2.M41; + r.M42 = m1.M41 * m2.M12 + m1.M42 * m2.M22 + m1.M43 * m2.M32 + m1.M44 * m2.M42; + r.M43 = m1.M41 * m2.M13 + m1.M42 * m2.M23 + m1.M43 * m2.M33 + m1.M44 * m2.M43; + r.M44 = m1.M41 * m2.M14 + m1.M42 * m2.M24 + m1.M43 * m2.M34 + m1.M44 * m2.M44; + + return r; + } + + public Matrix Transpose() + { + Matrix t; + + t.M11 = M11; + t.M12 = M21; + t.M13 = M31; + t.M14 = M41; + t.M21 = M12; + t.M22 = M22; + t.M23 = M32; + t.M24 = M42; + t.M31 = M13; + t.M32 = M23; + t.M33 = M33; + t.M34 = M43; + t.M41 = M14; + t.M42 = M24; + t.M43 = M34; + t.M44 = M44; + + return t; + } + + public static bool operator ==(Matrix m1, Matrix m2) => m1.Equals(m2); + public static bool operator !=(Matrix m1, Matrix m2) => !m1.Equals(m2); + + public Vector3 XAxis + { + get + { + return new Vector3(M11, M12, M13); + } + set + { + M11 = value.X; + M12 = value.Y; + M13 = value.Z; + } + } + + public Vector3 YAxis + { + get + { + return new Vector3(M21, M22, M23); + } + set + { + M21 = value.X; + M22 = value.Y; + M23 = value.Z; + } + } + + public Vector3 ZAxis + { + get + { + return new Vector3(M31, M32, M33); + } + set + { + M31 = value.X; + M32 = value.Y; + M33 = value.Z; + } + } + + public Vector3 Scale + { + get + { + return new Vector3(M11, M22, M33); + } + set + { + M11 = value.X; + M22 = value.Y; + M33 = value.Z; + } + } + + public Vector3 Translation + { + get + { + return new Vector3(M41, M42, M43); + } + set + { + M41 = value.X; + M42 = value.Y; + M43 = value.Z; + } + } + + public bool Equals(Matrix other) + { + return (M11 == other.M11 && M12 == other.M12 && M13 == other.M13 && M14 == other.M14 + && M21 == other.M21 && M22 == other.M22 && M23 == other.M23 && M24 == other.M24 + && M31 == other.M31 && M32 == other.M32 && M33 == other.M33 && M34 == other.M34 + && M41 == other.M41 && M42 == other.M42 && M43 == other.M43 && M44 == other.M44); + } + + public override bool Equals(object obj) => obj is Matrix && Equals((Matrix)obj); + + public override int GetHashCode() + { + return M11.GetHashCode() ^ M12.GetHashCode() ^ M13.GetHashCode() ^ M14.GetHashCode() + ^ M11.GetHashCode() ^ M12.GetHashCode() ^ M13.GetHashCode() ^ M14.GetHashCode() + ^ M11.GetHashCode() ^ M12.GetHashCode() ^ M13.GetHashCode() ^ M14.GetHashCode() + ^ M11.GetHashCode() ^ M12.GetHashCode() ^ M13.GetHashCode() ^ M14.GetHashCode(); + } + + public override string ToString() + { + return string.Format("{{M11:{0} M12:{1} M13:{2} M14:{3}}}\n{{M21:{4} M22:{5} M23:{6} M24:{7}}}\n{{M31:{8} M32:{9} M33:{10} M34:{11}}}\n{{M41:{12} M42:{13} M43:{14} M44:{15}}}", + M11, M12, M13, M14, + M21, M22, M23, M24, + M31, M32, M33, M34, + M41, M42, M43, M44); + } + + private static readonly Matrix identity = new Matrix( + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f); + + public static Matrix Identity => identity; + + public Vector3 ToEuler() + { + float a = M11; + float b = M21; + float c, s, r; + + if (b == 0.0f) + { + c = FMath.Sign(a); + s = 0.0f; + r = Math.Abs(a); + } + else if (a == 0.0f) + { + c = 0.0f; + s = FMath.Sign(b); + r = Math.Abs(b); + } + else if (Math.Abs(b) > Math.Abs(a)) + { + float t = a / b; + float u = FMath.Sign(b) * FMath.Sqrt(1.0f + t * t); + s = 1.0f / u; + c = s * t; + r = b * u; + } + else + { + float t = b / a; + float u = FMath.Sign(a) * FMath.Sqrt(1.0f + t * t); + c = 1.0f / u; + s = c * t; + r = a * u; + } + + Vector3 e; + e.Z = MathHelper.ToDegrees(-FMath.Atan2(s, c)); + e.Y = MathHelper.ToDegrees(FMath.Atan2(M31, r)); + e.X = MathHelper.ToDegrees(-FMath.Atan2(M32, M33)); + return e; + } + + public float Determinant() + { + var m11 = M11; + var m12 = M12; + var m13 = M13; + var m14 = M14; + var m21 = M21; + var m22 = M22; + var m23 = M23; + var m24 = M24; + var m31 = M31; + var m32 = M32; + var m33 = M33; + var m34 = M34; + var m41 = M41; + var m42 = M42; + var m43 = M43; + var m44 = M44; + + var d3434 = m33 * m44 - m34 * m43; + var d3424 = m32 * m44 - m34 * m42; + var d3423 = m32 * m43 - m33 * m42; + var d3414 = m31 * m44 - m34 * m41; + var d3413 = m31 * m43 - m33 * m41; + var d3412 = m31 * m42 - m32 * m41; + + return m11 * (m22 * d3434 - m23 * d3424 + m24 * d3423) + - m12 * (m21 * d3434 - m23 * d3414 + m24 * d3413) + + m13 * (m21 * d3424 - m22 * d3414 + m24 * d3412) + - m14 * (m21 * d3423 - m22 * d3413 + m23 * d3412); + } + + //Matrix m = Matrix.Identity; + //m *= Matrix.CreateScale(3.3f, 1.3f, 7.6f); + //m *= Matrix.CreateTranslation(2.3f, 4.5f, 6.7f); + //m *= Matrix.CreateRotationY(1.2f); + //m *= Matrix.CreateTranslation(2.3f, 4.5f, 6.7f); + //m *= Matrix.CreateRotationY(1.2f); + //m *= Matrix.CreateTranslation(2.3f, 4.5f, 6.7f); + //m *= Matrix.CreateRotationY(1.2f); + + //Vector3 s, t; + //Quaternion r; + //m.Decompose(out s, out r, out t); + //Matrix m2 = Matrix.CreateScale(s) * Matrix.CreateFromQuaternion(r) * Matrix.CreateTranslation(t); + + //Console.WriteLine(m2 - m); + //return 0; + + //[StructLayout(LayoutKind.Sequential)] + //private unsafe struct VectorBasis + //{ + // public Vector3* axis0; + // public Vector3* axis1; + // public Vector3* axis2; + //} + + //[StructLayout(LayoutKind.Sequential)] + //private struct CanonicalBasis + //{ + // public Vector3 axis0; + // public Vector3 axis1; + // public Vector3 axis2; + //} + + //public unsafe bool Decompose(out Vector3 outScale, out Quaternion outRotation, out Vector3 outTranslation) + //{ + // outTranslation.X = M41; + // outTranslation.Y = M42; + // outTranslation.Z = M43; + + // var rotation = new Matrix( + // M11, M12, M13, 0.0f, + // M21, M22, M23, 0.0f, + // M31, M32, M33, 0.0f, + // 0.0f, 0.0f, 0.0f, 1.0f); + + // var vectorBasis = new VectorBasis { + // axis0 = (Vector3*)&rotation.M11, + // axis1 = (Vector3*)&rotation.M21, + // axis2 = (Vector3*)&rotation.M31 + // }; + + // var canonicalBasis = new CanonicalBasis { + // axis0 = Vector3.UnitX, + // axis1 = Vector3.UnitY, + // axis2 = Vector3.UnitZ + // }; + + // var scale = new Vector3( + // vectorBasis.axis0->Length(), + // vectorBasis.axis1->Length(), + // vectorBasis.axis2->Length() + // ); + + // int xi, yi, zi; + + // if (scale.X < scale.Y) + // { + // if (scale.Y < scale.Z) + // { + // xi = 2; + // yi = 1; + // zi = 0; + // } + // else + // { + // xi = 1; + + // if (scale.X < scale.Z) + // { + // yi = 2; + // zi = 0; + // } + // else + // { + // yi = 0; + // zi = 2; + // } + // } + // } + // else + // { + // if (scale.X < scale.Z) + // { + // xi = 2; + // yi = 0; + // zi = 1; + // } + // else + // { + // xi = 0; + + // if (scale.Y < scale.Z) + // { + // yi = 2; + // zi = 1; + // } + // else + // { + // yi = 1; + // zi = 2; + // } + // } + // } + + // var pScale = &scale.X; + + // var pvBasis = &vectorBasis.axis0; + // var pcBasis = &canonicalBasis.axis0; + + // if (pScale[xi] < 0.0001f) + // { + // // + // // If the smallest scale is < 0.0001 then use the coresponding cannonical basis instead + // // + + // pvBasis[xi] = &pcBasis[xi]; + // } + // else + // { + // pvBasis[xi]->Normalize(); + // } + + // if (pScale[yi] < 0.0001f) + // { + // // + // // The second smallest scale is < 0.0001 too, build a perpendicular vector + // // + + // float fx = Math.Abs(pvBasis[xi]->X); + // float fy = Math.Abs(pvBasis[xi]->Y); + // float fz = Math.Abs(pvBasis[xi]->Z); + + // int yij; + + // if (fx < fy) + // { + // if (fy < fz) + // { + // yij = 0; + // } + // else + // { + // if (fx < fz) + // yij = 0; + // else + // yij = 2; + // } + // } + // else + // { + // if (fx < fz) + // { + // yij = 1; + // } + // else + // { + // if (fy < fz) + // yij = 1; + // else + // yij = 2; + // } + // } + + // pcBasis[yij] = Vector3.Cross(*pvBasis[yi], *pvBasis[xi]); + // } + + // pvBasis[yi]->Normalize(); + + // if (pScale[zi] < 0.0001f) + // *(pvBasis[zi]) = Vector3.Cross(*pvBasis[yi], *pvBasis[xi]); + // else + // pvBasis[zi]->Normalize(); + + // float rotDet = rotation.Determinant(); + + // if (rotDet < 0.0f) + // { + // pScale[xi] = -pScale[xi]; + // *(pvBasis[xi]) = -(*(pvBasis[xi])); + // rotDet = -rotDet; + // } + + // outScale = scale; + + // if (Math.Abs(rotDet - 1.0f) > 0.01f) + // { + // outRotation = Quaternion.Identity; + // return false; + // } + // else + // { + // outRotation = Quaternion.CreateFromRotationMatrix(rotation); + // return true; + // } + //} + } +} Index: /OniSplit/Math/Plane.cs =================================================================== --- /OniSplit/Math/Plane.cs (revision 1114) +++ /OniSplit/Math/Plane.cs (revision 1114) @@ -0,0 +1,95 @@ +using System; + +namespace Oni +{ + internal struct Plane : IEquatable + { + public Vector3 Normal; + public float D; + + public Plane(Vector3 normal, float d) + { + Normal = normal; + D = d; + } + + public Plane(Vector3 point1, Vector3 point2, Vector3 point3) + { + Normal = Vector3.Normalize(Vector3.Cross(point2 - point1, point3 - point1)); + D = -Vector3.Dot(Normal, point1); + } + + public float DotCoordinate(Vector3 point) => Vector3.Dot(Normal, point) + D; + + public float DotNormal(Vector3 value) => Vector3.Dot(Normal, value); + + public void Flip() + { + Normal = -Normal; + D = -D; + } + + public static Plane Flip(Plane plane) + { + plane.Normal = -plane.Normal; + plane.D = -plane.D; + + return plane; + } + + public static bool operator ==(Plane p1, Plane p2) => p1.D == p2.D && p1.Normal == p2.Normal; + public static bool operator !=(Plane p1, Plane p2) => p1.D != p2.D || p1.Normal != p2.Normal; + + public bool Equals(Plane other) => other.D == D && other.Normal == Normal; + + public override bool Equals(object obj) => obj is Plane && Equals((Plane)obj); + public override int GetHashCode() => Normal.GetHashCode() ^ D.GetHashCode(); + + public override string ToString() => $"{{Normal:{Normal} D:{D}}}"; + + public int Intersects(BoundingBox box) + { + Vector3 max, min; + + if (Normal.X >= 0.0f) + { + min.X = box.Min.X; + max.X = box.Max.X; + } + else + { + min.X = box.Max.X; + max.X = box.Min.X; + } + + if (Normal.Y >= 0.0f) + { + min.Y = box.Min.Y; + max.Y = box.Max.Y; + } + else + { + min.Y = box.Max.Y; + max.Y = box.Min.Y; + } + + if (Normal.Z >= 0.0f) + { + min.Z = box.Min.Z; + max.Z = box.Max.Z; + } + else + { + min.Z = box.Max.Z; + max.Z = box.Min.Z; + } + + if (Vector3.Dot(Normal, min) + D > 0.0f) + return 1; + else if (Vector3.Dot(Normal, max) + D < 0.0f) + return -1; + else + return 0; + } + } +} Index: /OniSplit/Math/Polygon2.cs =================================================================== --- /OniSplit/Math/Polygon2.cs (revision 1114) +++ /OniSplit/Math/Polygon2.cs (revision 1114) @@ -0,0 +1,16 @@ +namespace Oni +{ + internal struct Polygon2 + { + private readonly Vector2[] points; + + public Polygon2(Vector2[] points) + { + this.points = points; + } + + public int Length => points.Length; + + public Vector2 this[int index] => points[index]; + } +} Index: /OniSplit/Math/Polygon3.cs =================================================================== --- /OniSplit/Math/Polygon3.cs (revision 1114) +++ /OniSplit/Math/Polygon3.cs (revision 1114) @@ -0,0 +1,16 @@ +namespace Oni +{ + internal struct Polygon3 + { + private readonly Vector3[] points; + + public Polygon3(Vector3[] points) + { + this.points = points; + } + + public int Length => points.Length; + + public Vector3 this[int index] => points[index]; + } +} Index: /OniSplit/Math/Quaternion.cs =================================================================== --- /OniSplit/Math/Quaternion.cs (revision 1114) +++ /OniSplit/Math/Quaternion.cs (revision 1114) @@ -0,0 +1,326 @@ +using System; + +namespace Oni +{ + internal struct Quaternion : IEquatable + { + public float X; + public float Y; + public float Z; + public float W; + + public Quaternion(Vector3 xyz, float w) + { + X = xyz.X; + Y = xyz.Y; + Z = xyz.Z; + W = w; + } + + public Quaternion(float x, float y, float z, float w) + { + X = x; + Y = y; + Z = z; + W = w; + } + + public Quaternion(Vector4 xyzw) + { + X = xyzw.X; + Y = xyzw.Y; + Z = xyzw.Z; + W = xyzw.W; + } + + private Vector3 XYZ => new Vector3(X, Y, Z); + + public static Quaternion CreateFromAxisAngle(Vector3 axis, float angle) + { + float halfAngle = angle * 0.5f; + float sin = FMath.Sin(halfAngle); + float cos = FMath.Cos(halfAngle); + + return new Quaternion(axis * sin, cos); + } + + public void ToAxisAngle(out Vector3 axis, out float angle) + { + float halfAngle = FMath.Acos(W); + float sin = FMath.Sqrt(1 - W * W); + + if (sin < 1e-5f) + { + axis = XYZ; + angle = 0.0f; + } + else + { + axis = XYZ / sin; + angle = halfAngle * 2.0f; + } + } + + public static Quaternion CreateFromEulerXYZ(float x, float y, float z) + { + x = MathHelper.ToRadians(x); + y = MathHelper.ToRadians(y); + z = MathHelper.ToRadians(z); + + return CreateFromAxisAngle(Vector3.UnitX, x) + * CreateFromAxisAngle(Vector3.UnitY, y) + * CreateFromAxisAngle(Vector3.UnitZ, z); + } + + public Vector3 ToEulerXYZ() + { + Vector3 r; + + var p0 = -W; + var p1 = X; + var p2 = Y; + var p3 = Z; + var e = -1.0f; + + var s = 2.0f * (p0 * p2 + e * p1 * p3); + + if (s > 0.999f) + { + r.X = MathHelper.ToDegrees(-2.0f * (float)Math.Atan2(p1, p0)); + r.Y = -90.0f; + r.Z = 0.0f; + } + else if (s < -0.999f) + { + r.X = MathHelper.ToDegrees(2.0f * (float)Math.Atan2(p1, p0)); + r.Y = 90.0f; + r.Z = 0.0f; + } + else + { + r.X = -MathHelper.ToDegrees((float)Math.Atan2(2.0f * (p0 * p1 - e * p2 * p3), 1.0f - 2.0f * (p1 * p1 + p2 * p2))); + r.Y = -MathHelper.ToDegrees((float)Math.Asin(s)); + r.Z = -MathHelper.ToDegrees((float)Math.Atan2(2.0f * (p0 * p3 - e * p1 * p2), 1.0f - 2.0f * (p2 * p2 + p3 * p3))); + } + + return r; + } + + public static Quaternion CreateFromYawPitchRoll(float yaw, float pitch, float roll) + { + float halfRoll = roll * 0.5f; + float sinRoll = FMath.Sin(halfRoll); + float cosRoll = FMath.Cos(halfRoll); + + float halfPitch = pitch * 0.5f; + float sinPitch = FMath.Sin(halfPitch); + float cosPitch = FMath.Cos(halfPitch); + + float halfYaw = yaw * 0.5f; + float sinYaw = FMath.Sin(halfYaw); + float cosYaw = FMath.Cos(halfYaw); + + Quaternion r; + + r.X = (cosYaw * sinPitch * cosRoll) + (sinYaw * cosPitch * sinRoll); + r.Y = (sinYaw * cosPitch * cosRoll) - (cosYaw * sinPitch * sinRoll); + r.Z = (cosYaw * cosPitch * sinRoll) - (sinYaw * sinPitch * cosRoll); + r.W = (cosYaw * cosPitch * cosRoll) + (sinYaw * sinPitch * sinRoll); + + return r; + } + + public static Quaternion CreateFromRotationMatrix(Matrix m) + { + Quaternion q; + + float trace = m.M11 + m.M22 + m.M33; + + if (trace > 0.0f) + { + float s = FMath.Sqrt(1.0f + trace); + float inv2s = 0.5f / s; + q.X = (m.M23 - m.M32) * inv2s; + q.Y = (m.M31 - m.M13) * inv2s; + q.Z = (m.M12 - m.M21) * inv2s; + q.W = s * 0.5f; + } + else if (m.M11 >= m.M22 && m.M11 >= m.M33) + { + float s = FMath.Sqrt(1.0f + m.M11 - m.M22 - m.M33); + float inv2s = 0.5f / s; + q.X = s * 0.5f; + q.Y = (m.M12 + m.M21) * inv2s; + q.Z = (m.M13 + m.M31) * inv2s; + q.W = (m.M23 - m.M32) * inv2s; + } + else if (m.M22 > m.M33) + { + float s = FMath.Sqrt(1.0f - m.M11 + m.M22 - m.M33); + float inv2s = 0.5f / s; + q.X = (m.M21 + m.M12) * inv2s; + q.Y = s * 0.5f; + q.Z = (m.M32 + m.M23) * inv2s; + q.W = (m.M31 - m.M13) * inv2s; + } + else + { + float s = FMath.Sqrt(1.0f - m.M11 - m.M22 + m.M33); + float inv2s = 0.5f / s; + q.X = (m.M31 + m.M13) * inv2s; + q.Y = (m.M32 + m.M23) * inv2s; + q.Z = s * 0.5f; + q.W = (m.M12 - m.M21) * inv2s; + } + + return q; + } + + public static Quaternion Lerp(Quaternion q1, Quaternion q2, float amount) + { + float invAmount = 1.0f - amount; + + if (Dot(q1, q2) < 0.0f) + amount = -amount; + + q1.X = invAmount * q1.X + amount * q2.X; + q1.Y = invAmount * q1.Y + amount * q2.Y; + q1.Z = invAmount * q1.Z + amount * q2.Z; + q1.W = invAmount * q1.W + amount * q2.W; + + q1.Normalize(); + + return q1; + } + + public static float Dot(Quaternion q1, Quaternion q2) + => q1.X * q2.X + q1.Y * q2.Y + q1.Z * q2.Z + q1.W * q2.W; + + public static Quaternion operator +(Quaternion q1, Quaternion q2) + { + q1.X += q2.X; + q1.Y += q2.Y; + q1.Z += q2.Z; + q1.W += q2.W; + + return q1; + } + + public static Quaternion operator -(Quaternion q1, Quaternion q2) + { + q1.X -= q2.X; + q1.Y -= q2.Y; + q1.Z -= q2.Z; + q1.W -= q2.W; + + return q1; + } + + public static Quaternion operator *(Quaternion q1, Quaternion q2) => new Quaternion + { + X = q1.X * q2.W + q1.Y * q2.Z - q1.Z * q2.Y + q1.W * q2.X, + Y = -q1.X * q2.Z + q1.Y * q2.W + q1.Z * q2.X + q1.W * q2.Y, + Z = q1.X * q2.Y - q1.Y * q2.X + q1.Z * q2.W + q1.W * q2.Z, + W = -q1.X * q2.X - q1.Y * q2.Y - q1.Z * q2.Z + q1.W * q2.W, + }; + + public static Quaternion operator *(Quaternion q, float s) + { + q.X *= s; + q.Y *= s; + q.Z *= s; + q.W *= s; + + return q; + } + + public static bool operator ==(Quaternion q1, Quaternion q2) => q1.Equals(q2); + public static bool operator !=(Quaternion q1, Quaternion q2) => !q1.Equals(q2); + + public static Quaternion Conjugate(Quaternion q) + { + q.X = -q.X; + q.Y = -q.Y; + q.Z = -q.Z; + + return q; + } + + public Quaternion Inverse() + { + float inv = 1.0f / SquaredLength(); + + Quaternion r; + r.X = -X * inv; + r.Y = -Y * inv; + r.Z = -Z * inv; + r.W = W * inv; + return r; + } + + public void Normalize() + { + float f = 1.0f / Length(); + + X *= f; + Y *= f; + Z *= f; + W *= f; + } + + public float Length() => FMath.Sqrt(SquaredLength()); + + public float SquaredLength() => X * X + Y * Y + Z * Z + W * W; + + public bool Equals(Quaternion other) => X == other.X && Y == other.Y && Z == other.Z && W == other.W; + + public override bool Equals(object obj) => obj is Quaternion && Equals((Quaternion)obj); + + public override int GetHashCode() => X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode(); + + public override string ToString() => $"{{{X} {Y} {Z} {W}}}"; + + public Matrix ToMatrix() + { + float xx = X * X; + float yy = Y * Y; + float zz = Z * Z; + float xy = X * Y; + float zw = Z * W; + float zx = Z * X; + float yw = Y * W; + float yz = Y * Z; + float xw = X * W; + + Matrix m; + + m.M11 = 1.0f - 2.0f * (yy + zz); + m.M12 = 2.0f * (xy + zw); + m.M13 = 2.0f * (zx - yw); + m.M14 = 0.0f; + + m.M21 = 2.0f * (xy - zw); + m.M22 = 1.0f - 2.0f * (zz + xx); + m.M23 = 2.0f * (yz + xw); + m.M24 = 0.0f; + + m.M31 = 2.0f * (zx + yw); + m.M32 = 2.0f * (yz - xw); + m.M33 = 1.0f - 2.0f * (yy + xx); + m.M34 = 0.0f; + + m.M41 = 0.0f; + m.M42 = 0.0f; + m.M43 = 0.0f; + m.M44 = 1.0f; + + return m; + } + + public Vector4 ToVector4() => new Vector4(X, Y, Z, W); + + private static readonly Quaternion identity = new Quaternion(0.0f, 0.0f, 0.0f, 1.0f); + + public static Quaternion Identity => identity; + } +} Index: /OniSplit/Math/Vector2.cs =================================================================== --- /OniSplit/Math/Vector2.cs (revision 1114) +++ /OniSplit/Math/Vector2.cs (revision 1114) @@ -0,0 +1,96 @@ +using System; + +namespace Oni +{ + internal struct Vector2 : IEquatable + { + public float X; + public float Y; + + public Vector2(float x, float y) + { + X = x; + Y = y; + } + + public Vector2(float all) + { + X = all; + Y = all; + } + + public static Vector2 operator +(Vector2 v1, Vector2 v2) => new Vector2 + { + X = v1.X + v2.X, + Y = v1.Y + v2.Y + }; + + public static Vector2 operator -(Vector2 v1, Vector2 v2) => new Vector2 + { + X = v1.X - v2.X, + Y = v1.Y - v2.Y + }; + + public static float Dot(Vector2 v1, Vector2 v2) => v1.X * v2.X + v1.Y * v2.Y; + + public static Vector2 Normalize(Vector2 v) => v * (1.0f / v.Length()); + + public void Normalize() + { + float f = 1.0f / Length(); + + X *= f; + Y *= f; + } + + public float Length() => FMath.Sqrt(X * X + Y * Y); + + public static Vector2 operator *(Vector2 v, float s) + { + v.X *= s; + v.Y *= s; + + return v; + } + + public static Vector2 operator *(float s, Vector2 v) + { + v.X *= s; + v.Y *= s; + + return v; + } + + public static Vector2 operator /(Vector2 v, float s) => v * (1.0f / s); + + public static Vector2 Min(Vector2 v1, Vector2 v2) => new Vector2 + { + X = (v1.X < v2.X) ? v1.X : v2.X, + Y = (v1.Y < v2.Y) ? v1.Y : v2.Y + }; + + public static Vector2 Max(Vector2 v1, Vector2 v2) => new Vector2 + { + X = (v1.X > v2.X) ? v1.X : v2.X, + Y = (v1.Y > v2.Y) ? v1.Y : v2.Y + }; + + public static bool operator ==(Vector2 v1, Vector2 v2) => v1.X == v2.X && v1.Y == v2.Y; + public static bool operator !=(Vector2 v1, Vector2 v2) => v1.X != v2.X || v1.Y != v2.Y; + public bool Equals(Vector2 other) => X == other.X && Y == other.Y; + public override bool Equals(object obj) => obj is Vector2 && Equals((Vector2)obj); + public override int GetHashCode() => X.GetHashCode() ^ Y.GetHashCode(); + + public override string ToString() => $"{{{X} {Y}}}"; + + private static Vector2 zero = new Vector2(0.0f, 0.0f); + private static Vector2 one = new Vector2(1.0f, 1.0f); + private static Vector2 unitX = new Vector2(1.0f, 0.0f); + private static Vector2 unitY = new Vector2(0.0f, 1.0f); + + public static Vector2 Zero => zero; + public static Vector2 One => one; + public static Vector2 UnitX => unitX; + public static Vector2 UnitY => unitY; + } +} Index: /OniSplit/Math/Vector3.cs =================================================================== --- /OniSplit/Math/Vector3.cs (revision 1114) +++ /OniSplit/Math/Vector3.cs (revision 1114) @@ -0,0 +1,369 @@ +using System; + +namespace Oni +{ + internal struct Vector3 : IEquatable + { + public float X; + public float Y; + public float Z; + + public Vector3(float all) + { + X = all; + Y = all; + Z = all; + } + + public Vector3(float x, float y, float z) + { + X = x; + Y = y; + Z = z; + } + + public Vector3(float[] values, int index = 0) + { + int i = index * 3; + + X = values[i + 0]; + Y = values[i + 1]; + Z = values[i + 2]; + } + + public void CopyTo(float[] values, int index = 0) + { + values[index + 0] = X; + values[index + 1] = Y; + values[index + 2] = Z; + } + + public Vector2 XZ => new Vector2(X, Z); + + public static Vector3 operator +(Vector3 v1, Vector3 v2) + { + v1.X += v2.X; + v1.Y += v2.Y; + v1.Z += v2.Z; + + return v1; + } + + public static Vector3 operator -(Vector3 v1, Vector3 v2) + { + v1.X -= v2.X; + v1.Y -= v2.Y; + v1.Z -= v2.Z; + + return v1; + } + + public static Vector3 operator -(Vector3 v) + { + v.X = -v.X; + v.Y = -v.Y; + v.Z = -v.Z; + + return v; + } + + public static Vector3 operator *(Vector3 v, float s) + { + v.X *= s; + v.Y *= s; + v.Z *= s; + + return v; + } + + public static Vector3 operator *(float s, Vector3 v) + { + v.X *= s; + v.Y *= s; + v.Z *= s; + + return v; + } + + public static Vector3 operator *(Vector3 v1, Vector3 v2) => new Vector3 + { + X = v1.X * v2.X, + Y = v1.Y * v2.Y, + Z = v1.Z * v2.Z, + }; + + public static Vector3 operator /(Vector3 v, float s) => v * (1.0f / s); + + public static Vector3 operator /(Vector3 v1, Vector3 v2) => new Vector3 + { + X = v1.X /= v2.X, + Y = v1.Y /= v2.Y, + Z = v1.Z /= v2.Z + }; + + public static void Add(ref Vector3 v1, ref Vector3 v2, out Vector3 r) + { + r.X = v1.X + v2.X; + r.Y = v1.Y + v2.Y; + r.Z = v1.Z + v2.Z; + } + + public static void Substract(ref Vector3 v1, ref Vector3 v2, out Vector3 r) + { + r.X = v1.X - v2.X; + r.Y = v1.Y - v2.Y; + r.Z = v1.Z - v2.Z; + } + + public static void Multiply(ref Vector3 v, float f, out Vector3 r) + { + r.X = v.X * f; + r.Y = v.Y * f; + r.Z = v.Z * f; + } + + public void Scale(float scale) + { + X *= scale; + Y *= scale; + Z *= scale; + } + + public static Vector3 Clamp(Vector3 v, Vector3 min, Vector3 max) + { + Vector3 r; + + float x = v.X; + x = (x > max.X) ? max.X : x; + x = (x < min.X) ? min.X : x; + + float y = v.Y; + y = (y > max.Y) ? max.Y : y; + y = (y < min.Y) ? min.Y : y; + + float z = v.Z; + z = (z > max.Z) ? max.Z : z; + z = (z < min.Z) ? min.Z : z; + + r.X = x; + r.Y = y; + r.Z = z; + + return r; + } + + public static Vector3 Cross(Vector3 v1, Vector3 v2) + { + return new Vector3( + v1.Y * v2.Z - v1.Z * v2.Y, + v1.Z * v2.X - v1.X * v2.Z, + v1.X * v2.Y - v1.Y * v2.X); + } + + public static void Cross(ref Vector3 v1, ref Vector3 v2, out Vector3 r) + { + r = new Vector3( + v1.Y * v2.Z - v1.Z * v2.Y, + v1.Z * v2.X - v1.X * v2.Z, + v1.X * v2.Y - v1.Y * v2.X); + } + + public static float Dot(Vector3 v1, Vector3 v2) + { + return v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z; + } + + public static float Dot(ref Vector3 v1, ref Vector3 v2) => v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z; + + public float Dot(ref Vector3 v) => X * v.X + Y * v.Y + Z * v.Z; + + public static Vector3 Transform(Vector3 v, Quaternion q) + { + Quaternion vq = new Quaternion(v, 0.0f); + q = q * vq * Quaternion.Conjugate(q); + return new Vector3(q.X, q.Y, q.Z); + } + + public static Vector3 Transform(Vector3 v, ref Matrix m) + { + return new Vector3( + v.X * m.M11 + v.Y * m.M21 + v.Z * m.M31 + m.M41, + v.X * m.M12 + v.Y * m.M22 + v.Z * m.M32 + m.M42, + v.X * m.M13 + v.Y * m.M23 + v.Z * m.M33 + m.M43); + } + + public static void Transform(ref Vector3 v, ref Matrix m, out Vector3 r) + { + r.X = v.X * m.M11 + v.Y * m.M21 + v.Z * m.M31 + m.M41; + r.Y = v.X * m.M12 + v.Y * m.M22 + v.Z * m.M32 + m.M42; + r.Z = v.X * m.M13 + v.Y * m.M23 + v.Z * m.M33 + m.M43; + } + + public static Vector3 TransformNormal(Vector3 v, ref Matrix m) + { + return new Vector3( + v.X * m.M11 + v.Y * m.M21 + v.Z * m.M31, + v.X * m.M12 + v.Y * m.M22 + v.Z * m.M32, + v.X * m.M13 + v.Y * m.M23 + v.Z * m.M33); + } + + public static void Transform(Vector3[] v, ref Matrix m, Vector3[] r) + { + for (int i = 0; i < v.Length; i++) + { + float x = v[i].X; + float y = v[i].Y; + float z = v[i].Z; + + r[i].X = x * m.M11 + y * m.M21 + z * m.M31 + m.M41; + r[i].Y = x * m.M12 + y * m.M22 + z * m.M32 + m.M42; + r[i].Z = x * m.M13 + y * m.M23 + z * m.M33 + m.M43; + } + } + + public static Vector3[] Transform(Vector3[] v, ref Matrix m) + { + var r = new Vector3[v.Length]; + Transform(v, ref m, r); + return r; + } + + public static void TransformNormal(Vector3[] v, ref Matrix m, Vector3[] r) + { + for (int i = 0; i < v.Length; i++) + { + float x = v[i].X; + float y = v[i].Y; + float z = v[i].Z; + + r[i].X = x * m.M11 + y * m.M21 + z * m.M31; + r[i].Y = x * m.M12 + y * m.M22 + z * m.M32; + r[i].Z = x * m.M13 + y * m.M23 + z * m.M33; + } + } + + public static Vector3[] TransformNormal(Vector3[] v, ref Matrix m) + { + var r = new Vector3[v.Length]; + TransformNormal(v, ref m, r); + return r; + } + + public static Vector3 Min(Vector3 v1, Vector3 v2) + { + if (v2.X < v1.X) + v1.X = v2.X; + + if (v2.Y < v1.Y) + v1.Y = v2.Y; + + if (v2.Z < v1.Z) + v1.Z = v2.Z; + + return v1; + } + + public static void Min(ref Vector3 v1, ref Vector3 v2, out Vector3 r) + { + r.X = (v1.X < v2.X) ? v1.X : v2.X; + r.Y = (v1.Y < v2.Y) ? v1.Y : v2.Y; + r.Z = (v1.Z < v2.Z) ? v1.Z : v2.Z; + } + + public static Vector3 Max(Vector3 v1, Vector3 v2) + { + if (v2.X > v1.X) + v1.X = v2.X; + + if (v2.Y > v1.Y) + v1.Y = v2.Y; + + if (v2.Z > v1.Z) + v1.Z = v2.Z; + + return v1; + } + + public static void Max(ref Vector3 v1, ref Vector3 v2, out Vector3 r) + { + r.X = (v1.X > v2.X) ? v1.X : v2.X; + r.Y = (v1.Y > v2.Y) ? v1.Y : v2.Y; + r.Z = (v1.Z > v2.Z) ? v1.Z : v2.Z; + } + + public static Vector3 Normalize(Vector3 v) => v * (1.0f / v.Length()); + + public void Normalize() + { + float k = 1.0f / Length(); + + X *= k; + Y *= k; + Z *= k; + } + + public float LengthSquared() => X * X + Y * Y + Z * Z; + + public float Length() => FMath.Sqrt(LengthSquared()); + + public static float Distance(Vector3 v1, Vector3 v2) => FMath.Sqrt((v2 - v1).LengthSquared()); + + public static float DistanceSquared(Vector3 v1, Vector3 v2) => (v2 - v1).LengthSquared(); + + public static Vector3 Lerp(Vector3 v1, Vector3 v2, float amount) => v1 + (v2 - v1) * amount; + + public static bool EqualsEps(Vector3 v1, Vector3 v2) + { + Vector3 d = v2 - v1; + + float dx = Math.Abs(d.X); + float dy = Math.Abs(d.Y); + float dz = Math.Abs(d.Z); + + return (dx < 0.0001f && dy < 0.0001f && dz < 0.0001f); + } + + public static bool operator ==(Vector3 v1, Vector3 v2) => v1.X == v2.X && v1.Y == v2.Y && v1.Z == v2.Z; + public static bool operator !=(Vector3 v1, Vector3 v2) => v1.X != v2.X || v1.Y != v2.Y || v1.Z != v2.Z; + + public bool Equals(Vector3 other) => X == other.X && Y == other.Y && Z == other.Z; + public override bool Equals(object obj) => obj is Vector3 && Equals((Vector3)obj); + public override int GetHashCode() => X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode(); + + public override string ToString() => $"{{{X} {Y} {Z}}}"; + + private static Vector3 zero = new Vector3(); + private static Vector3 one = new Vector3(1.0f); + private static Vector3 up = new Vector3(0.0f, 1.0f, 0.0f); + private static Vector3 down = new Vector3(0.0f, -1.0f, 0.0f); + private static Vector3 right = new Vector3(1.0f, 0.0f, 0.0f); + private static Vector3 left = new Vector3(-1.0f, 0.0f, 0.0f); + private static Vector3 backward = new Vector3(0.0f, 0.0f, 1.0f); + private static Vector3 forward = new Vector3(0.0f, 0.0f, -1.0f); + + public static Vector3 Zero => zero; + public static Vector3 One => one; + public static Vector3 Up => up; + public static Vector3 Down => down; + public static Vector3 Left => left; + public static Vector3 Right => right; + public static Vector3 Backward => backward; + public static Vector3 Forward => forward; + public static Vector3 UnitX => right; + public static Vector3 UnitY => up; + public static Vector3 UnitZ => backward; + + public float this[int i] + { + get + { + if (i == 1) + return Y; + else if (i < 1) + return X; + else + return Z; + } + } + } +} Index: /OniSplit/Math/Vector4.cs =================================================================== --- /OniSplit/Math/Vector4.cs (revision 1114) +++ /OniSplit/Math/Vector4.cs (revision 1114) @@ -0,0 +1,146 @@ +using System; + +namespace Oni +{ + internal struct Vector4 : IEquatable + { + public float X; + public float Y; + public float Z; + public float W; + + public Vector4(float all) + { + X = all; + Y = all; + Z = all; + W = all; + } + + public Vector4(Vector3 v, float w) + { + X = v.X; + Y = v.Y; + Z = v.Z; + W = w; + } + + public Vector4(float x, float y, float z, float w) + { + X = x; + Y = y; + Z = z; + W = w; + } + + public Vector3 XYZ + { + get + { + return new Vector3(X, Y, Z); + } + set + { + X = value.X; + Y = value.Y; + Z = value.Z; + } + } + + public static Vector4 operator +(Vector4 v1, Vector4 v2) + { + v1.X += v2.X; + v1.Y += v2.Y; + v1.Z += v2.Z; + v1.W += v2.W; + + return v1; + } + + public static Vector4 operator -(Vector4 v1, Vector4 v2) + { + v1.X -= v2.X; + v1.Y -= v2.Y; + v1.Z -= v2.Z; + v1.W -= v2.W; + + return v1; + } + + public static Vector4 operator *(Vector4 v, float s) + { + v.X *= s; + v.Y *= s; + v.Z *= s; + v.W *= s; + + return v; + } + + public static Vector4 operator *(float s, Vector4 v) => v * s; + + public static Vector4 operator /(Vector4 v, float s) => v * (1.0f / s); + + public static float Dot(Vector4 v1, Vector4 v2) => v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z + v1.W * v2.W; + + public static Vector4 Min(Vector4 v1, Vector4 v2) + { + v1.X = (v1.X < v2.X) ? v1.X : v2.X; + v1.Y = (v1.Y < v2.Y) ? v1.Y : v2.Y; + v1.Z = (v1.Z < v2.Z) ? v1.Z : v2.Z; + v1.W = (v1.W < v2.W) ? v1.W : v2.W; + + return v1; + } + + public static Vector4 Max(Vector4 v1, Vector4 v2) + { + v1.X = (v1.X > v2.X) ? v1.X : v2.X; + v1.Y = (v1.Y > v2.Y) ? v1.Y : v2.Y; + v1.Z = (v1.Z > v2.Z) ? v1.Z : v2.Z; + v1.W = (v1.W > v2.W) ? v1.W : v2.W; + + return v1; + } + + public static Vector4 Normalize(Vector4 v) => v * (1.0f / v.Length()); + + public float LengthSquared() => X * X + Y * Y + Z * Z + W * W; + public float Length() => FMath.Sqrt(LengthSquared()); + + public static bool EqualsEps(Vector4 v1, Vector4 v2) + { + Vector4 d = v2 - v1; + + float dx = Math.Abs(d.X); + float dy = Math.Abs(d.Y); + float dz = Math.Abs(d.Z); + float dw = Math.Abs(d.W); + + return (dx < 0.0001f && dy < 0.0001f && dz < 0.0001f && dw < 0.0001f); + } + + public static bool operator ==(Vector4 v1, Vector4 v2) => v1.X == v2.X && v1.Y == v2.Y && v1.Z == v2.Z && v1.W == v2.W; + public static bool operator !=(Vector4 v1, Vector4 v2) => v1.X != v2.X || v1.Y != v2.Y || v1.Z != v2.Z || v1.W != v2.W; + + public bool Equals(Vector4 other) => X == other.X && Y == other.Y && Z == other.Z && W == other.W; + public override bool Equals(object obj) => obj is Vector4 && Equals((Vector4)obj); + public override int GetHashCode() => X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode(); + + public override string ToString() => $"{{{X} {Y} {Z} {W}}}"; + + private static Vector4 zero = new Vector4(); + private static Vector4 one = new Vector4(1.0f); + private static Vector4 unitX = new Vector4(1.0f, 0.0f, 0.0f, 0.0f); + private static Vector4 unitY = new Vector4(0.0f, 1.0f, 0.0f, 0.0f); + private static Vector4 unitZ = new Vector4(0.0f, 0.0f, 1.0f, 0.0f); + private static Vector4 unitW = new Vector4(0.0f, 0.0f, 0.0f, 1.0f); + + public static Vector4 Zero => zero; + public static Vector4 One => one; + public static Vector4 UnitX => unitX; + public static Vector4 UnitY => unitY; + public static Vector4 UnitZ => unitZ; + public static Vector4 UnitW => unitW; + } +} Index: /OniSplit/Metadata/BinaryMetadata.cs =================================================================== --- /OniSplit/Metadata/BinaryMetadata.cs (revision 1114) +++ /OniSplit/Metadata/BinaryMetadata.cs (revision 1114) @@ -0,0 +1,156 @@ +using System; +using System.Collections.Generic; + +namespace Oni.Metadata +{ + internal class BinaryMetadata + { + private static MetaStruct bobj = new MetaStruct("ObjectHeader", + new Field(MetaType.Int32, "ObjectId"), + new Field(MetaType.Int32, "ObjectFlags"), + new Field(MetaType.Vector3, "Position"), + new Field(MetaType.Vector3, "Rotation") + ); + + private static MetaStruct cons = new MetaStruct("Console", bobj, + new Field(MetaType.String(63), "ClassName"), + new Field(MetaType.Int16, "DoorId"), + new Field(MetaType.Int16, "Flags"), + new Field(MetaType.String(63), "DisabledTexture"), + new Field(MetaType.String(63), "EnabledTexture"), + new Field(MetaType.String(63), "UsedTexture"), + new Field(MetaType.ShortVarArray(new MetaStruct("ConsoleAction", + new Field(MetaType.Int16, "ActionType"), + new Field(MetaType.Int16, "TargetId"), // if actionType != 1 + new Field(MetaType.String32, "ScriptFunction") // if actionType == 1 + )), "Actions") + ); + + private static MetaStruct door = new MetaStruct("Door", bobj, + new Field(MetaType.String(63), "ClassName"), + new Field(MetaType.Int16, "DoorId"), + new Field(MetaType.Int16, ""), + new Field(MetaType.Int16, "Flags"), + new Field(MetaType.Vector3, "Center"), + new Field(MetaType.Float, "ActivationRadius"), + new Field(MetaType.String(63), "Texture1"), + new Field(MetaType.String(63), "Texture2"), + new Field(MetaType.Padding(5)) + ); + + private static MetaStruct flag = new MetaStruct("Flag", bobj, + new Field(MetaType.Color, "Color"), + new Field(MetaType.Int16, "Prefix"), + new Field(MetaType.Int16, "FlagId"), + new Field(MetaType.String128, "Notes") + ); + + private static MetaStruct furn = new MetaStruct("Furniture", bobj, + new Field(MetaType.String32, "ClassName"), + new Field(MetaType.String48, "Particle") + ); + + private static MetaStruct part = new MetaStruct("Particle", bobj, + new Field(MetaType.String64, "ClassName"), + new Field(MetaType.String48, "Name"), + new Field(MetaType.Int16, "Flags"), + new Field(MetaType.Float, "DecalXScale"), + new Field(MetaType.Float, "DecalYScale"), + new Field(MetaType.Int16, "DecalRotation") + ); + + private static MetaStruct pwru = new MetaStruct("Powerup", bobj, + new Field(MetaType.Int32, "Type") + ); + + private static MetaStruct sndg = new MetaStruct("Sound", bobj, + new Field(MetaType.String32, "ClassName"), + new Field(MetaType.Int32, "GeometryType"), + new Field(MetaType.BoundingBox, "BoundingBox"), // if geometry == VLME + new Field(MetaType.Float, "MinVolumeRadius"), // if geometry == SPHR + new Field(MetaType.Float, "MaxVolumeRadius"), // if geometry == SPHR + new Field(MetaType.Float, "Volume"), + new Field(MetaType.Float, "Pitch") + ); + + private static MetaStruct trge = new MetaStruct("Trigger", bobj, + new Field(MetaType.String(63), "ClassName"), + new Field(MetaType.Int16, "TriggerId"), + new Field(MetaType.Int16, "Flags"), + new Field(MetaType.Color, "Color"), + new Field(MetaType.Float, "StartPosition"), + new Field(MetaType.Float, "Speed"), + new Field(MetaType.Int32, "Count"), + new Field(MetaType.Int16, ""), + new Field(MetaType.ShortVarArray(new MetaStruct("TriggerAction", + new Field(MetaType.Int16, "ActionType"), + new Field(MetaType.Int16, "TurretId"), // if actionType != 1 + new Field(MetaType.String(34), "ScriptFunction") // if actionType == 1 + )), "Actions"), + new Field(MetaType.Byte, "") + ); + + private static MetaStruct turr = new MetaStruct("Turret", bobj, + new Field(MetaType.String(63), "ClassName"), + new Field(MetaType.Int16, "TurretId"), + new Field(MetaType.Int16, "Flags"), + new Field(MetaType.Padding(36)), + new Field(MetaType.Int32, "TargetedTeams"), + new Field(MetaType.Padding(1)) + ); + + private static MetaStruct weap = new MetaStruct("Weapon", bobj, + new Field(MetaType.String32, "ClassName") + ); + + private static MetaType osbdAmbient = new MetaStruct("OSBDAmbient", + new Field(MetaType.Int32, "Version"), + new Field(MetaType.Int32, "Priority"), + new Field(MetaType.Int32, "Flags"), + new Field(MetaType.Float, "Unknown1"), + new Field(MetaType.Float, "MinElapsedTime"), + new Field(MetaType.Float, "MaxElapsedTime"), + new Field(MetaType.Float, "MinVolumeDistance"), + new Field(MetaType.Float, "MaxVolumeDistance"), + new Field(MetaType.String32, "DetailGroup"), + new Field(MetaType.String32, "Track1Group"), + new Field(MetaType.String32, "Track2Group"), + new Field(MetaType.String32, "InGroup"), + new Field(MetaType.String32, "OutGroup"), + new Field(MetaType.Int32, "Unknown2"), // v >= 5 + new Field(MetaType.Float, "Unknown3") // v >= 6 + ); + + private static MetaType osbdImpulse = new MetaStruct("OSBDImpulse", + new Field(MetaType.Int32, "Version"), + new Field(MetaType.String32, "Group"), + new Field(MetaType.Int32, "Priority"), + new Field(MetaType.Float, "MinVolumeDistance"), + new Field(MetaType.Float, "MaxVolumeDistance"), + new Field(MetaType.Float, "MinVolumeAngle"), + new Field(MetaType.Float, "MaxVolumeAngle"), + new Field(MetaType.Int32, "Unknown1"), + new Field(MetaType.Int32, "Unknown2"), // v >= 4 + new Field(MetaType.String32, "AlternateImpulse"), // v >= 4 + new Field(MetaType.Int32, "Unknown3"), // v >= 5 + new Field(MetaType.Int32, "Unknown4") // v >= 6 + ); + + private static MetaType osbdGroup = new MetaStruct("OSBDGroup", + new Field(MetaType.Int32, "Version"), + new Field(MetaType.Float, "Volume"), // v >= 2 + new Field(MetaType.Float, "Pitch"), // v >= 3 + new Field(MetaType.Int16, "PreventRepeat"), // v >= 6 + new Field(MetaType.Int16, "PreviousPermutation"), // v >= 6 + new Field(MetaType.Int32, "ChannelCount"), + new Field(MetaType.VarArray(new MetaStruct("OSBDGroupPermutation", + new Field(MetaType.Int32, "Weight"), + new Field(MetaType.Float, "MinVolume"), + new Field(MetaType.Float, "MaxVolume"), + new Field(MetaType.Float, "MinPitch"), + new Field(MetaType.Float, "MaxPitch"), + new Field(MetaType.String32, "Sound") + )), "Permutations") + ); + } +} Index: /OniSplit/Metadata/BinaryPartField.cs =================================================================== --- /OniSplit/Metadata/BinaryPartField.cs (revision 1114) +++ /OniSplit/Metadata/BinaryPartField.cs (revision 1114) @@ -0,0 +1,51 @@ +using System; + +namespace Oni.Metadata +{ + internal class BinaryPartField : Field + { + private string sizeFieldName; + private int sizeMultiplier; + private MetaType rawType; + + public BinaryPartField(MetaType offsetType, string name) + : this(offsetType, name, null, 0) + { + } + + public BinaryPartField(MetaType offsetType, string name, string sizeFieldName) + : this(offsetType, name, sizeFieldName, 1) + { + } + + public BinaryPartField(MetaType offsetType, string name, int size) + : this(offsetType, name, null, size) + { + } + + public BinaryPartField(MetaType offsetType, string name, int size, MetaType rawType) + : this(offsetType, name, null, size, rawType) + { + } + + public BinaryPartField(MetaType offsetType, string name, string sizeFieldName, int sizeMultiplier) + : this(offsetType, name, sizeFieldName, sizeMultiplier, null) + { + } + + public BinaryPartField(MetaType offsetType, string name, string sizeFieldName, int sizeMultiplier, MetaType rawType) + : base(offsetType, name) + { + if (offsetType != MetaType.RawOffset && offsetType != MetaType.SepOffset) + throw new ArgumentException("Offset type can only be RawOffset or SepOffset", "offsetType"); + + this.sizeFieldName = sizeFieldName; + this.sizeMultiplier = sizeMultiplier; + this.rawType = rawType; + } + + public string SizeFieldName => sizeFieldName; + public int SizeMultiplier => sizeMultiplier; + public MetaType RawType => rawType; + } +} Index: /OniSplit/Metadata/BinaryTag.cs =================================================================== --- /OniSplit/Metadata/BinaryTag.cs (revision 1114) +++ /OniSplit/Metadata/BinaryTag.cs (revision 1114) @@ -0,0 +1,11 @@ +namespace Oni.Metadata +{ + internal enum BinaryTag + { + PAR3 = 0x50415233, + OBJC = 0x4f424a43, + TMBD = 0x544d4244, + ONIE = 0x4f4e4945, + SABD = 0x53414244 + } +} Index: /OniSplit/Metadata/CompareVisitor.cs =================================================================== --- /OniSplit/Metadata/CompareVisitor.cs (revision 1114) +++ /OniSplit/Metadata/CompareVisitor.cs (revision 1114) @@ -0,0 +1,86 @@ +namespace Oni.Metadata +{ + internal class CompareVisitor : MetaTypeVisitor + { + private readonly BinaryReader reader1; + private readonly BinaryReader reader2; + private bool equals = true; + + public CompareVisitor(BinaryReader reader1, BinaryReader reader2) + { + this.reader1 = reader1; + this.reader2 = reader2; + } + + public bool AreEquals => equals; + + public override void VisitByte(MetaByte type) => equals = (reader1.ReadByte() == reader2.ReadByte()); + public override void VisitInt16(MetaInt16 type) => equals = (reader1.ReadInt16() == reader2.ReadInt16()); + public override void VisitInt32(MetaInt32 type) => equals = (reader1.ReadInt32() == reader2.ReadInt32()); + public override void VisitUInt32(MetaUInt32 type) => equals = (reader1.ReadUInt32() == reader2.ReadUInt32()); + public override void VisitInt64(MetaInt64 type) => equals = (reader1.ReadInt64() == reader2.ReadInt64()); + public override void VisitUInt64(MetaUInt64 type) => equals = (reader1.ReadUInt64() == reader2.ReadUInt64()); + public override void VisitFloat(MetaFloat type) => equals = (reader1.ReadSingle() == reader2.ReadSingle()); + public override void VisitColor(MetaColor type) => equals = (reader1.ReadInt32() == reader2.ReadInt32()); + public override void VisitRawOffset(MetaRawOffset type) => equals = (reader1.ReadInt32() == reader2.ReadInt32()); + public override void VisitSepOffset(MetaSepOffset type) => equals = (reader1.ReadInt32() == reader2.ReadInt32()); + public override void VisitPointer(MetaPointer type) => equals = (reader1.ReadInt32() == reader2.ReadInt32()); + public override void VisitString(MetaString type) => equals = (reader1.ReadString(type.Count) == reader2.ReadString(type.Count)); + + public override void VisitPadding(MetaPadding type) + { + reader1.Skip(type.Count); + reader2.Skip(type.Count); + } + + public override void VisitStruct(MetaStruct type) + { + foreach (var field in type.Fields) + { + field.Type.Accept(this); + + if (!equals) + break; + } + } + + public override void VisitArray(MetaArray type) + { + CompareArray(type.ElementType, type.Count); + } + + public override void VisitVarArray(MetaVarArray type) + { + int count1, count2; + + if (type.CountField.Type == MetaType.Int16) + { + count1 = reader1.ReadInt16(); + count2 = reader2.ReadInt16(); + } + else + { + count1 = reader1.ReadInt32(); + count2 = reader2.ReadInt32(); + } + + equals = (count1 == count2); + + if (!equals) + return; + + CompareArray(type.ElementType, count1); + } + + private void CompareArray(MetaType elementType, int count) + { + for (int i = 0; i < count; i++) + { + elementType.Accept(this); + + if (!equals) + break; + } + } + } +} Index: /OniSplit/Metadata/CopyVisitor.cs =================================================================== --- /OniSplit/Metadata/CopyVisitor.cs (revision 1114) +++ /OniSplit/Metadata/CopyVisitor.cs (revision 1114) @@ -0,0 +1,300 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Oni.Metadata +{ + internal class CopyVisitor : MetaTypeVisitor + { + #region Private data + private BinaryReader input; + private BinaryWriter output; + private Action callback; + private Stack activeFields; + private MetaType topLevelType; + private MetaType currentType; + private byte[] buffer; + private int fieldSize; + private int position; + #endregion + + #region private class ActiveField + + private class ActiveField + { + public Field Field; + public int Index; + + public ActiveField(Field field) + { + Field = field; + Index = -1; + } + } + + #endregion + + public CopyVisitor(BinaryReader reader, BinaryWriter writer, Action callback) + { + this.input = reader; + this.output = writer; + this.callback = callback; + this.activeFields = new Stack(); + } + + public MetaType TopLevelType => topLevelType; + + public MetaType Type => currentType; + + public Field Field + { + get + { + if (activeFields.Count == 0) + return null; + + return activeFields.Peek().Field; + } + } + + public int Position => position; + + public byte GetByte() => buffer[0]; + + public short GetInt16() => (short)(buffer[0] | (buffer[1] << 8)); + + public ushort GetUInt16() => (ushort)(buffer[0] | (buffer[1] << 8)); + + public int GetInt32() => buffer[0] | (buffer[1] << 8) | (buffer[2] << 16) | (buffer[3] << 24); + + public uint GetUInt32() => (uint)buffer[0] | ((uint)buffer[1] << 8) | ((uint)buffer[2] << 16) | ((uint)buffer[3] << 24); + + public void SetInt32(int value) + { + buffer[0] = (byte)value; + buffer[1] = (byte)(value >> 8); + buffer[2] = (byte)(value >> 16); + buffer[3] = (byte)(value >> 24); + } + + public string GetCurrentFieldName() + { + if (activeFields.Count == 0) + return null; + + List names = new List(); + + foreach (ActiveField state in activeFields) + { + if (string.IsNullOrEmpty(state.Field.Name)) + return null; + + if (state.Index >= 0) + names.Add(string.Format("{0}[{1}]", state.Field.Name, state.Index)); + else + names.Add(state.Field.Name); + } + + names.Add(topLevelType.Name); + names.Reverse(); + + return string.Join(".", names.ToArray()); + } + + public string GetParentFieldName() + { + if (activeFields.Count == 0) + return null; + + List names = new List(); + + foreach (ActiveField state in activeFields) + { + if (string.IsNullOrEmpty(state.Field.Name)) + return null; + + if (state.Index >= 0) + names.Add(string.Format("{0}[{1}]", state.Field.Name, state.Index)); + else + names.Add(state.Field.Name); + } + + names.Add(topLevelType.Name); + names.Reverse(); + names.RemoveAt(names.Count - 1); + + return string.Join(".", names.ToArray()); + } + + public override void VisitByte(MetaByte type) => CopyBytes(type); + public override void VisitInt16(MetaInt16 type) => CopyBytes(type); + public override void VisitUInt16(MetaUInt16 type) => CopyBytes(type); + public override void VisitInt32(MetaInt32 type) => CopyBytes(type); + public override void VisitUInt32(MetaUInt32 type) => CopyBytes(type); + public override void VisitInt64(MetaInt64 type) => CopyBytes(type); + public override void VisitUInt64(MetaUInt64 type) => CopyBytes(type); + public override void VisitFloat(MetaFloat type) => CopyBytes(type); + public override void VisitColor(MetaColor type) => CopyBytes(type); + public override void VisitRawOffset(MetaRawOffset type) => CopyBytes(type); + public override void VisitSepOffset(MetaSepOffset type) => CopyBytes(type); + public override void VisitPointer(MetaPointer type) => CopyBytes(type); + public override void VisitBoundingBox(MetaBoundingBox type) => CopyBytes(type); + public override void VisitBoundingSphere(MetaBoundingSphere type) => CopyBytes(type); + public override void VisitMatrix4x3(MetaMatrix4x3 type) => CopyBytes(type); + public override void VisitPlane(MetaPlane type) => CopyBytes(type); + public override void VisitQuaternion(MetaQuaternion type) => CopyBytes(type); + public override void VisitVector2(MetaVector2 type) => CopyBytes(type); + public override void VisitVector3(MetaVector3 type) => CopyBytes(type); + + private void CopyBytes(MetaType type) + { + BeginCopy(type, 1); + EndCopy(); + } + + public override void VisitString(MetaString type) + { + BeginCopy(type, 1); + + bool zeroFound = false; + + for (int i = 0; i < type.Size; i++) + { + if (zeroFound) + buffer[i] = 0; + else if (buffer[i] == 0) + zeroFound = true; + } + + EndCopy(); + } + + public override void VisitPadding(MetaPadding type) + { + BeginCopy(type, 1); + + if (type.FillByte == 0) + { + Array.Clear(buffer, 0, type.Size); + } + else + { + for (int i = 0; i < type.Size; i++) + buffer[i] = type.FillByte; + } + + EndCopy(); + } + + public override void VisitStruct(MetaStruct type) + { + if (topLevelType == null) + topLevelType = type; + + foreach (Field field in type.Fields) + { + BeginCopyField(field); + field.Type.Accept(this); + EndCopyField(field); + } + } + + internal void BeginCopyField(Field field) + { + activeFields.Push(new ActiveField(field)); + } + + internal void EndCopyField(Field field) + { + if (activeFields.Peek().Field != field) + throw new InvalidOperationException(); + + activeFields.Pop(); + } + + public override void VisitArray(MetaArray type) + { + CopyArray(type.ElementType, type.Count); + } + + public override void VisitVarArray(MetaVarArray type) + { + BeginCopyField(type.CountField); + type.CountField.Type.Accept(this); + EndCopyField(type.CountField); + + int length; + + if (type.CountField.Type == MetaType.Int16) + length = GetInt16(); + else + length = GetInt32(); + + if (length < 0) + throw new InvalidDataException(string.Format("Invalid array length: 0x{0:x} at offset 0x{1:x}", length, position)); + + CopyArray(type.ElementType, length); + } + + private void CopyArray(MetaType elementType, int count) + { + if (elementType.IsBlittable) + { + BeginCopy(elementType, count); + EndCopy(); + return; + } + + for (int i = 0; i < count; i++) + { + BeginCopyArrayElement(i); + elementType.Accept(this); + EndCopyArrayElement(i); + } + } + + private void BeginCopyArrayElement(int index) + { + if (activeFields.Count == 0) + return; + + activeFields.Peek().Index = index; + } + + private void EndCopyArrayElement(int index) + { + if (activeFields.Count == 0) + return; + + ActiveField field = activeFields.Peek(); + + if (field.Index != index) + throw new InvalidOperationException(); + + field.Index = -1; + } + + private void BeginCopy(MetaType type, int count) + { + currentType = type; + + fieldSize = type.Size * count; + + if (buffer == null || buffer.Length < fieldSize) + buffer = new byte[fieldSize * 2]; + + input.Read(buffer, 0, fieldSize); + } + + private void EndCopy() + { + if (callback != null) + callback(this); + + if (output != null) + output.Write(buffer, 0, fieldSize); + + position += fieldSize; + } + } +} Index: /OniSplit/Metadata/DumpVisitor.cs =================================================================== --- /OniSplit/Metadata/DumpVisitor.cs (revision 1114) +++ /OniSplit/Metadata/DumpVisitor.cs (revision 1114) @@ -0,0 +1,262 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Oni.Metadata +{ + internal class DumpVisitor : MetaTypeVisitor + { + #region Private data + private readonly InstanceMetadata metadata; + private readonly TextWriter writer; + private Stack activeFields; + private MetaType topLevelType; + private MetaType currentType; + private int fieldSize; + private int position; + private string indent = ""; + private Field field; + #endregion + + #region private class ActiveField + + private class ActiveField + { + public Field Field; + public int Index; + + public ActiveField(Field field) + { + this.Field = field; + this.Index = -1; + } + } + + #endregion + + public DumpVisitor(TextWriter writer, InstanceMetadata metadata) + { + this.writer = writer; + this.metadata = metadata; + } + + public MetaType TopLevelType => topLevelType; + public MetaType Type => currentType; + + public Field Field + { + get + { + if (activeFields.Count == 0) + return null; + + return activeFields.Peek().Field; + } + } + + public int Position => position; + + public string GetCurrentFieldName() + { + if (activeFields.Count == 0) + return null; + + List names = new List(); + + foreach (ActiveField state in activeFields) + { + if (string.IsNullOrEmpty(state.Field.Name)) + return null; + + if (state.Index >= 0) + names.Add(string.Format("{0}[{1}]", state.Field.Name, state.Index)); + else + names.Add(state.Field.Name); + } + + names.Add(topLevelType.Name); + names.Reverse(); + + return string.Join(".", names.ToArray()); + } + + public string GetParentFieldName() + { + if (activeFields.Count == 0) + return null; + + var names = new List(); + + foreach (ActiveField state in activeFields) + { + if (string.IsNullOrEmpty(state.Field.Name)) + return null; + + if (state.Index >= 0) + names.Add(string.Format("{0}[{1}]", state.Field.Name, state.Index)); + else + names.Add(state.Field.Name); + } + + names.Add(topLevelType.Name); + names.Reverse(); + names.RemoveAt(names.Count - 1); + + return string.Join(".", names.ToArray()); + } + + public override void VisitByte(MetaByte type) + { + writer.Write(indent); + writer.Write("uint8_t"); + } + + public override void VisitInt16(MetaInt16 type) + { + writer.Write(indent); + writer.Write("int16_t"); + } + + public override void VisitUInt16(MetaUInt16 type) + { + writer.Write(indent); + writer.Write("uint16_t"); + } + + public override void VisitInt32(MetaInt32 type) + { + writer.Write(indent); + writer.Write("int32_t"); + } + + public override void VisitUInt32(MetaUInt32 type) + { + writer.Write(indent); + writer.Write("uint32_t"); + } + + public override void VisitInt64(MetaInt64 type) + { + writer.Write(indent); + writer.Write("int64_t"); + } + + public override void VisitUInt64(MetaUInt64 type) + { + writer.Write(indent); + writer.Write("uint64_t"); + } + + public override void VisitFloat(MetaFloat type) + { + writer.Write(indent); + writer.Write("float"); + } + + public override void VisitColor(MetaColor type) + { + writer.Write(indent); + writer.Write("uint32_t"); + } + + public override void VisitRawOffset(MetaRawOffset type) + { + writer.Write(indent); + writer.Write("void*"); + } + + public override void VisitSepOffset(MetaSepOffset type) + { + writer.Write(indent); + writer.Write("void*"); + } + + public override void VisitPointer(MetaPointer type) + { + writer.Write(indent); + writer.Write("{0}*", metadata.GetTemplate(type.Tag).Type.Name); + } + + public override void VisitBoundingBox(MetaBoundingBox type) + { + writer.Write(indent); + writer.Write("bbox"); + } + + public override void VisitBoundingSphere(MetaBoundingSphere type) + { + writer.Write(indent); + writer.Write("bsphere"); + } + + public override void VisitMatrix4x3(MetaMatrix4x3 type) + { + writer.Write(indent); + writer.Write("matrix43"); + } + + public override void VisitPlane(MetaPlane type) + { + writer.Write(indent); + writer.Write("plane"); + } + + public override void VisitQuaternion(MetaQuaternion type) + { + writer.Write(indent); + writer.Write("quat"); + } + + public override void VisitVector2(MetaVector2 type) + { + writer.Write(indent); + writer.Write("vec2"); + } + + public override void VisitVector3(MetaVector3 type) + { + writer.Write(indent); + writer.Write("vec3"); + } + + public override void VisitString(MetaString type) + { + writer.Write(indent); + writer.Write("const char*"); + } + + public override void VisitPadding(MetaPadding type) + { + writer.Write(indent); + writer.Write("std::array<{0}>", type.Size); + } + + public override void VisitStruct(MetaStruct type) + { + if (topLevelType == null) + topLevelType = type; + + writer.WriteLine(); + writer.WriteLine("struct {0} {{", type.Name); + indent += "\t"; + + foreach (Field field in type.Fields) + { + field.Type.Accept(this); + writer.WriteLine(" {0};", field.Name); + } + + indent = indent.Substring(0, indent.Length - 1); + writer.WriteLine("};"); + } + + public override void VisitArray(MetaArray type) + { + writer.Write(indent); + } + + public override void VisitVarArray(MetaVarArray type) + { + } + } +} Index: /OniSplit/Metadata/Field.cs =================================================================== --- /OniSplit/Metadata/Field.cs (revision 1114) +++ /OniSplit/Metadata/Field.cs (revision 1114) @@ -0,0 +1,17 @@ +namespace Oni.Metadata +{ + internal class Field + { + private readonly string name; + private readonly MetaType type; + + public Field(MetaType type, string name = null) + { + this.type = type; + this.name = name; + } + + public MetaType Type => type; + public string Name => name; + } +} Index: /OniSplit/Metadata/IMetaTypeVisitor.cs =================================================================== --- /OniSplit/Metadata/IMetaTypeVisitor.cs (revision 1114) +++ /OniSplit/Metadata/IMetaTypeVisitor.cs (revision 1114) @@ -0,0 +1,31 @@ +namespace Oni.Metadata +{ + internal interface IMetaTypeVisitor + { + void VisitStruct(MetaStruct type); + void VisitArray(MetaArray type); + void VisitVarArray(MetaVarArray type); + void VisitEnum(MetaEnum type); + void VisitByte(MetaByte type); + void VisitInt16(MetaInt16 type); + void VisitUInt16(MetaUInt16 type); + void VisitInt32(MetaInt32 type); + void VisitUInt32(MetaUInt32 type); + void VisitInt64(MetaInt64 type); + void VisitUInt64(MetaUInt64 type); + void VisitFloat(MetaFloat type); + void VisitString(MetaString type); + void VisitColor(MetaColor type); + void VisitVector2(MetaVector2 type); + void VisitVector3(MetaVector3 type); + void VisitQuaternion(MetaQuaternion type); + void VisitMatrix4x3(MetaMatrix4x3 type); + void VisitPlane(MetaPlane type); + void VisitBoundingSphere(MetaBoundingSphere type); + void VisitBoundingBox(MetaBoundingBox type); + void VisitPointer(MetaPointer type); + void VisitRawOffset(MetaRawOffset type); + void VisitSepOffset(MetaSepOffset type); + void VisitPadding(MetaPadding type); + } +} Index: /OniSplit/Metadata/InstanceMetadata.cs =================================================================== --- /OniSplit/Metadata/InstanceMetadata.cs (revision 1114) +++ /OniSplit/Metadata/InstanceMetadata.cs (revision 1114) @@ -0,0 +1,3091 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Oni.Metadata +{ + internal abstract class InstanceMetadata + { + private static readonly MetaStruct aiSoundConstants = new MetaStruct("AISoundConstants", + new Field(MetaType.Byte, "TauntProbability"), + new Field(MetaType.Byte, "AlertProbability"), + new Field(MetaType.Byte, "StartleProbability"), + new Field(MetaType.Byte, "CheckBodyProbability"), + new Field(MetaType.Byte, "PursueProbability"), + new Field(MetaType.Byte, "CoverProbability"), + new Field(MetaType.Byte, "SuperPunchProbability"), + new Field(MetaType.Byte, "SuperKickProbability"), + new Field(MetaType.Byte, "Super3Probability"), + new Field(MetaType.Byte, "Super4Probability"), + new Field(MetaType.Padding(2)), + new Field(MetaType.String32, "TauntSound"), + new Field(MetaType.String32, "AlertSound"), + new Field(MetaType.String32, "StartleSound"), + new Field(MetaType.String32, "CheckBodySound"), + new Field(MetaType.String32, "PursueSound"), + new Field(MetaType.String32, "CoverSound"), + new Field(MetaType.String32, "SuperPunchSound"), + new Field(MetaType.String32, "SuperKickSound"), + new Field(MetaType.String32, "Super3Sound"), + new Field(MetaType.String32, "Super4Sound")); + + private static readonly MetaStruct aiVisionConstants = new MetaStruct("AIVisionConstants", + new Field(MetaType.Float, "CentralDistance"), + new Field(MetaType.Float, "PeripheralDistance"), + new Field(MetaType.Float, "VerticalRange"), + new Field(MetaType.Float, "CentralRange"), + new Field(MetaType.Float, "CentralMax"), + new Field(MetaType.Float, "PeripheralRange"), + new Field(MetaType.Float, "PeripheralMax")); + + private static readonly MetaStruct aiTargeting = new MetaStruct("AITargeting", + // parameters for how we shoot if startled + new Field(MetaType.Float, "StartleMissAngle"), + new Field(MetaType.Float, "StartleMissDistance"), + // target prediction + new Field(MetaType.Float, "PredictAmount"), + new Field(MetaType.Int32, "PredictPositionDelayFrames"), + new Field(MetaType.Int32, "PredictDelayFrames"), + new Field(MetaType.Int32, "PredictVelocityFrames"), + new Field(MetaType.Int32, "PredictTrendFrames")); + + private static readonly MetaType aiWeaponSkill = new MetaStruct("AIWeaponSkill", + new Field(MetaType.Float, "RecoilCompensation"), + new Field(MetaType.Float, "BestAimingAngle"), + new Field(MetaType.Float, "ShotGroupError"), + new Field(MetaType.Float, "ShotGroupDecay"), + new Field(MetaType.Float, "ShootingInaccuracyMultiplier"), + new Field(MetaType.Int16, "MinShotDelay"), + new Field(MetaType.Int16, "MaxShotDelay")); + + [Flags] + public enum AIFiringModeFlags : uint + { + None = 0, + NoWildShots = 1, + } + + private static readonly MetaStruct aiFiringMode = new MetaStruct("AIFiringMode", + new Field(MetaType.Enum(), "Flags"), + new Field(MetaType.Matrix4x3, "InverseDirection"), + new Field(MetaType.Vector3, "Direction"), + new Field(MetaType.Vector3, "Origin"), + new Field(MetaType.Float, "PredictionSpeed"), + new Field(MetaType.Float, "MaxInaccuracyAngle"), + new Field(MetaType.Float, "AimRadius"), + new Field(MetaType.Float, "AISoundRadius"), + new Field(MetaType.Float, "MinShootingDistance"), + new Field(MetaType.Float, "MaxShootingDistance"), + new Field(MetaType.Int16, "MaxStartleMisses"), + new Field(MetaType.Int16, "SkillIndex"), + new Field(MetaType.Int32, "FightTimer"), + new Field(MetaType.Float, "ProjectileSpeed"), + new Field(MetaType.Float, "ProjectileGravity"), + new Field(MetaType.Float, "FireSpreadLength"), + new Field(MetaType.Float, "FireSpreadWidth"), + new Field(MetaType.Float, "FireSpreadSkew") + ); + + // + // AI Character Setup Array template + // + + public enum AISACharacterTeam : ushort + { + Konoko = 0, + TCTF = 1, + Syndicate = 2, + Neutral = 3, + SecurityGuard = 4, + RogueKonoko = 5, + Switzerland = 6, + SyndicateAccessory = 7 + } + + [Flags] + public enum AISACharacterFlags : ushort + { + None = 0, + AI = 0x0001, + AutoFreeze = 0x0002, + Neutral = 0x0004, + TurnGuard = 0x0008 + } + + private static readonly MetaStruct aisa = new MetaStruct("AISAInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(new MetaStruct("AISACharacter", + new Field(MetaType.String32, "Name"), + new Field(MetaType.Int16, "ScriptId"), + new Field(MetaType.Int16, "FlagId"), + new Field(MetaType.Enum(), "Flags"), + new Field(MetaType.Enum(), "Team"), + new Field(MetaType.Pointer(TemplateTag.ONCC), "Class"), + new Field(MetaType.Padding(36)), + new Field(new MetaStruct("CharacterScripts", + new Field(MetaType.String32, "Spawn"), + new Field(MetaType.String32, "Die"), + new Field(MetaType.String32, "Combat"), + new Field(MetaType.String32, "Alarm"), + new Field(MetaType.String32, "Hurt"), + new Field(MetaType.String32, "Defeated"), + new Field(MetaType.String32, "OutOfAmmo"), + new Field(MetaType.String32, "NoPath")), "Scripts"), + new Field(MetaType.Pointer(TemplateTag.ONWC), "WeaponClass"), + new Field(MetaType.Int16, "Ammo"), + new Field(MetaType.Padding(10)) + )), "Characters") + ); + + // + // Adjacency Array template + // + + private static readonly MetaStruct akaa = new MetaStruct("AKAAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("AKAAElement", + new Field(MetaType.Int32, "Bnv"), + new Field(MetaType.Int32, "Quad"), + new Field(MetaType.Padding(4)) + )), "Elements") + ); + + // + // BSP Tree Node Array template + // + + private static readonly MetaStruct abna = new MetaStruct("ABNAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("ABNAElement", + new Field(MetaType.Int32, "Quad"), + new Field(MetaType.Int32, "Plane"), + new Field(MetaType.Int32, "Front"), + new Field(MetaType.Int32, "Back") + )), "Elements") + ); + + // + // BNV Node Array template + // + + private static readonly MetaStruct akva = new MetaStruct("AKVAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("AKVANode", + new Field(MetaType.Int32, "BspTree"), + new Field(MetaType.Int32, "Id"), + new Field(MetaType.Int32, "FirstSide"), + new Field(MetaType.Int32, "LastSide"), + new Field(MetaType.Int32, "ChildBnv"), + new Field(MetaType.Int32, "SiblingBnv"), + new Field(MetaType.Padding(4, 0xff)), + new Field(MetaType.Int32, "GridXTiles"), + new Field(MetaType.Int32, "GridZTiles"), + new BinaryPartField(MetaType.RawOffset, "DataOffset", "DataSize"), + new Field(MetaType.Int32, "DataSize"), + new Field(MetaType.Float, "TileSize"), + new Field(MetaType.BoundingBox, "BoundingBox"), + new Field(MetaType.Int16, "GridXOffset"), + new Field(MetaType.Int16, "GridZOffset"), + new Field(MetaType.Int32, "NodeId"), + new Field(MetaType.Padding(12)), + new Field(MetaType.Int32, "Flags"), + new Field(MetaType.Plane, "Floor"), + new Field(MetaType.Float, "Height") + )), "Nodes") + ); + + // + // Side Array template + // + + private static readonly MetaStruct akba = new MetaStruct("AKBAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("AKBASide", + new Field(MetaType.Int32, "Plane"), + //new Field(MetaType.Padding(4, 0x7f)), + new Field(MetaType.Int32, "FirstAdjacency"), + new Field(MetaType.Int32, "LastAdjacency"), + new Field(MetaType.Padding(16)) + )), "Sides") + ); + + // + // BSP Node Array template + // + + private static readonly MetaStruct akbp = new MetaStruct("AKBPInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(new MetaStruct("AKBPNode", + new Field(MetaType.Int32, "Plane"), + new Field(MetaType.Int32, "Back"), + new Field(MetaType.Int32, "Front") + )), "Nodes") + ); + + // + // Akira Environment template + // + + private static readonly MetaStruct akev = new MetaStruct("AKEVInstance", + new Field(MetaType.Pointer(TemplateTag.PNTA), "Points"), + new Field(MetaType.Pointer(TemplateTag.PLEA), "Planes"), + new Field(MetaType.Pointer(TemplateTag.TXCA), "TextureCoordinates"), + new Field(MetaType.Pointer(TemplateTag.AGQG), "Quads"), + new Field(MetaType.Pointer(TemplateTag.AGQR), "QuadTextures"), + new Field(MetaType.Pointer(TemplateTag.AGQC), "QuadCollision"), + new Field(MetaType.Pointer(TemplateTag.AGDB), "Debug"), + new Field(MetaType.Pointer(TemplateTag.TXMA), "Textures"), + new Field(MetaType.Pointer(TemplateTag.AKVA), "BnvNodes"), + new Field(MetaType.Pointer(TemplateTag.AKBA), "BnvSides"), + new Field(MetaType.Pointer(TemplateTag.IDXA), "QuadGroupList"), + new Field(MetaType.Pointer(TemplateTag.IDXA), "QuadGroupId"), + new Field(MetaType.Pointer(TemplateTag.AKBP), "BnvBspTree"), + new Field(MetaType.Pointer(TemplateTag.ABNA), "TransparencyBspTree"), + new Field(MetaType.Pointer(TemplateTag.AKOT), "Octtree"), + new Field(MetaType.Pointer(TemplateTag.AKAA), "BnvAdjacency"), + new Field(MetaType.Pointer(TemplateTag.AKDA), "DoorFrames"), + new Field(MetaType.BoundingBox, "BoundingBox"), + new Field(MetaType.Padding(24)), + new Field(MetaType.Float, "") + ); + + // + // Gunk Quad Collision Array template + // + + private static readonly MetaStruct agqc = new MetaStruct("AGQCInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("AGQCElement", + new Field(MetaType.Int32, "Plane"), + new Field(MetaType.BoundingBox, "BoundingBox") + )), "Elements") + ); + + // + // Gunk Quad General Array template + // + + [Flags] + private enum AGQGFlags : uint + { + None = 0, + + DoorFrame = 0x01, + Ghost = 0x02, + StairsUp = 0x04, + StairsDown = 0x08, + + Stairs = 0x10, + Transparent = 0x80, + TwoSided = 0x0200, + NoCollision = 0x0800, + Invisible = 0x00002000, + NoObjectCollision = 0x4000, + NoCharacterCollision = 0x8000, + NoOcclusion = 0x010000, + Danger = 0x020000, + GridIgnore = 0x400000, + NoDecals = 0x800000, + Furniture = 0x01000000, + + SoundTransparent = 0x08000000, + Impassable = 0x10000000, + + Triangle = 0x00000040, + Horizontal = 0x00080000, + Vertical = 0x00100000, + + ProjectionBit0 = 0x02000000, + ProjectionBit1 = 0x04000000, + } + + private static readonly MetaStruct agqg = new MetaStruct("AGQGInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("AGQGQuad", + new Field(MetaType.Array(4, MetaType.Int32), "Points"), + new Field(MetaType.Array(4, MetaType.Int32), "TextureCoordinates"), + new Field(MetaType.Array(4, MetaType.Color), "Colors"), + new Field(MetaType.Enum(), "Flags"), + new Field(MetaType.Int32, "ObjectId") + )), "Quads") + ); + + // + // Gunk Quad Render Array template + // + + private static readonly MetaStruct agqr = new MetaStruct("AGQRInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("AGQRElement", + new Field(MetaType.UInt16, "Texture"), + new Field(MetaType.Padding(2)) + )), "Elements") + ); + + // + // Oct tree template + // + + private static readonly MetaStruct akot = new MetaStruct("AKOTInstance", + new Field(MetaType.Pointer(TemplateTag.OTIT), "Nodes"), + new Field(MetaType.Pointer(TemplateTag.OTLF), "Leafs"), + new Field(MetaType.Pointer(TemplateTag.QTNA), "QuadTree"), + new Field(MetaType.Pointer(TemplateTag.IDXA), "GunkQuad"), + new Field(MetaType.Pointer(TemplateTag.IDXA), "Bnv") + ); + + // + // Oct tree interior node Array template + // + + private static readonly MetaStruct otit = new MetaStruct("OTITInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("OTITNode", + new Field(MetaType.Array(8, MetaType.Int32), "Children") + )), "Nodes") + ); + + // + // Oct tree leaf node Array template + // + + private static readonly MetaStruct otlf = new MetaStruct("OTLFInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("OTLFNode", + new Field(MetaType.Int32, "PackedGunkQuadList"), + new Field(MetaType.Array(6, MetaType.Int32), "Neighbours"), + new Field(MetaType.Int32, "PackedPositionAndSize"), + new Field(MetaType.Int32, "PackedBnvList") + )), "Nodes") + ); + + // + // Quad tree node Array template + // + + private static readonly MetaStruct qtna = new MetaStruct("QTNAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("QTNANode", + new Field(MetaType.Array(4, MetaType.Int32), "Children") + )), "Nodes") + ); + + // + // Env Particle Array template + // + + [Flags] + internal enum ENVPFlags : ushort + { + None = 0x00, + NotInitiallyCreated = 0x02, + } + + private static readonly MetaStruct envp = new MetaStruct("ENVPInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(new MetaStruct("ENVPParticle", + new Field(MetaType.String64, "Class"), + new Field(MetaType.String48, "Tag"), + new Field(MetaType.Matrix4x3, "Transform"), + new Field(MetaType.Vector2, "DecalScale"), + new Field(MetaType.Enum(), "Flags"), + new Field(MetaType.Padding(38)) + )), "Particles") + ); + + // + // Geometry template + // + + private static readonly MetaStruct m3gm = new MetaStruct("M3GMInstance", + new Field(MetaType.Padding(4)), + new Field(MetaType.Pointer(TemplateTag.PNTA), "Points"), + new Field(MetaType.Pointer(TemplateTag.VCRA), "VertexNormals"), + new Field(MetaType.Pointer(TemplateTag.VCRA), "FaceNormals"), + new Field(MetaType.Pointer(TemplateTag.TXCA), "TextureCoordinates"), + new Field(MetaType.Pointer(TemplateTag.IDXA), "TriangleStrips"), + new Field(MetaType.Pointer(TemplateTag.IDXA), "FaceNormalIndices"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Texture"), + new Field(MetaType.Padding(4)) + ); + + // + // GeometryArray template + // + + private static readonly MetaStruct m3ga = new MetaStruct("M3GAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(MetaType.Pointer(TemplateTag.M3GM)), "Geometries") + ); + + // + // Plane Equation Array template + // + + private static readonly MetaStruct plea = new MetaStruct("PLEAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(MetaType.Plane), "Planes") + ); + + // + // 3D Point Array template + // + + private static readonly MetaStruct pnta = new MetaStruct("PNTAInstance", + new Field(MetaType.Padding(12)), + new Field(MetaType.BoundingBox, "BoundingBox"), + new Field(MetaType.BoundingSphere, "BoundingSphere"), + new Field(MetaType.VarArray(MetaType.Vector3), "Positions") + ); + + // + // Texture Coordinate Array template + // + + private static readonly MetaStruct txca = new MetaStruct("TXCAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(MetaType.Vector2), "TexCoords") + ); + + // + // Texture Map Animation template + // + + private static readonly MetaStruct txan = new MetaStruct("TXANInstance", + new Field(MetaType.Padding(12)), + new Field(MetaType.Int16, "Speed"), + new Field(MetaType.Int16, ""), + new Field(MetaType.Padding(4)), + new Field(MetaType.VarArray(MetaType.Pointer(TemplateTag.TXMP)), "Textures") + ); + + // + // Texture map array template + // + + private static readonly MetaStruct txma = new MetaStruct("TXMAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(MetaType.Pointer(TemplateTag.TXMP)), "Textures") + ); + + // + // Texture Map Big template + // + + private static readonly MetaStruct txmb = new MetaStruct("TXMBInstance", + new Field(MetaType.Padding(8)), + new Field(MetaType.Int16, "Width"), + new Field(MetaType.Int16, "Height"), + new Field(MetaType.Padding(8)), + new Field(MetaType.VarArray(MetaType.Pointer(TemplateTag.TXMP)), "Textures") + ); + + // + // 3D Vector Array template + // + + private static readonly MetaStruct vcra = new MetaStruct("VCRAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(MetaType.Vector3), "Normals") + ); + + // + // Impact template + // + + private static readonly MetaStruct impt = new MetaStruct("ImptInstance", + new Field(MetaType.Padding(2, 0xff)), + new Field(MetaType.Padding(6)), + new Field(MetaType.Pointer(TemplateTag.Impt), "ParentImpact") + ); + + // + // Material template + // + + private static readonly MetaStruct mtrl = new MetaStruct("MtrlInstance", + new Field(MetaType.Padding(2, 0xff)), + new Field(MetaType.Padding(6)), + new Field(MetaType.Pointer(TemplateTag.Mtrl), "ParentMaterial") + ); + + // + // Console template + // + + [Flags] + public enum CONSFlags : uint + { + None = 0x00, + AlarmConsole = 0x01 + } + + private static readonly MetaStruct cons = new MetaStruct("CONSInstance", + new Field(MetaType.Enum(), "Flags"), + new Field(MetaType.Vector3, "Position"), + new Field(MetaType.Vector3, "Orientation"), + new Field(MetaType.Pointer(TemplateTag.OFGA), "ConsoleGeometry"), + new Field(MetaType.Pointer(TemplateTag.M3GM), "ScreenGeometry"), + new Field(MetaType.Enum(), "ScreenGunkFlags"), + new Field(MetaType.String32, "InactiveTexture"), + new Field(MetaType.String32, "ActiveTexture"), + new Field(MetaType.String32, "UsedTexture") + ); + + // + // Door template + // + + public enum DOORSoundType + { + None = -1, + Unimportant = 0, + Interesting = 1, + Danger = 2, + Melee = 3, + Gunfire = 4, + } + + public enum DOORSoundAllow : uint + { + All = 0, + Combat = 1, + Gunfire = 2, + None = 3 + } + + private static readonly MetaStruct door = new MetaStruct("DOORInstance", + new Field(MetaType.Array(2, MetaType.Pointer(TemplateTag.OFGA)), "Geometries"), + new Field(MetaType.Pointer(TemplateTag.OBAN), "Animation"), + new Field(MetaType.Float, "AISoundAttenuation"), + new Field(MetaType.Enum(), "AISoundAllow"), + new Field(MetaType.Enum(), "AISoundType"), + new Field(MetaType.Float, "AISoundDistance"), + new Field(MetaType.String32, "OpenSound"), + new Field(MetaType.String32, "CloseSound"), + new Field(MetaType.Padding(8)) + ); + + // + // Object Furn Geom Array template + // + + private static readonly MetaStruct ofga = new MetaStruct("OFGAInstance", + new Field(MetaType.Padding(16)), + new Field(MetaType.Pointer(TemplateTag.ENVP), "EnvParticle"), + new Field(MetaType.VarArray(new MetaStruct("OFGAElement", + new Field(MetaType.Enum(), "GunkFlags"), + new Field(MetaType.Pointer(TemplateTag.M3GM), "Geometry"), + new Field(MetaType.Padding(4)) + //new Field(MetaType.InstanceLink(TemplateTag.OBLS), "LightSource") + )), "Elements") + ); + + private static readonly MetaStruct obls = new MetaStruct("OBLSInstance", + new Field(MetaType.Int32, "Type"), + new Field(MetaType.Int32, "Flags"), + new Field(MetaType.Vector3, "Color"), + new Field(MetaType.Float, "Intensity"), + new Field(MetaType.Float, "BeamAngle"), + new Field(MetaType.Float, "FieldAngle") + ); + + // + // Trigger template + // + + private static readonly MetaStruct trig = new MetaStruct("TRIGInstance", + new Field(MetaType.Color, "Color"), // ignored + new Field(MetaType.UInt16, "TimeOn"), + new Field(MetaType.UInt16, "TimeOff"), + new Field(MetaType.Float, "StartOffset"), + new Field(MetaType.Float, "AnimScale"), + new Field(MetaType.Pointer(TemplateTag.M3GM), "BaseGeometry"), + new Field(MetaType.Padding(4)), // ls data + new Field(MetaType.Enum(), "BaseGunkFlags"), + new Field(MetaType.Pointer(TemplateTag.TRGE), "Emitter"), + new Field(MetaType.Pointer(TemplateTag.OBAN), "Animation"), + new Field(MetaType.String32, "ActiveSound"), + new Field(MetaType.String32, "TriggerSound"), + new Field(MetaType.Padding(8)) + ); + + // + // Trigger Emitter template + // + + private static readonly MetaStruct trge = new MetaStruct("TRGEInstance", + new Field(MetaType.Vector3, "Position"), + new Field(MetaType.Vector3, "Direction"), + new Field(MetaType.Pointer(TemplateTag.M3GM), "Geometry"), + new Field(MetaType.Enum(), "GunkFlags") + ); + + // + // Turret template + // + + private static readonly MetaStruct turr = new MetaStruct("TURRInstance", + new Field(MetaType.String32, "Name"), + new Field(MetaType.Padding(32)), // base name + new Field(MetaType.Padding(14)), // flags, free time, reload time, barrel count, recoil anim type, reload anim type, max ammo + new Field(MetaType.Int16, "ParticleCount"), // attachment count + new Field(MetaType.Int16, ""), // shooter count + new Field(MetaType.Padding(6)), // pad, aiming speed + new Field(MetaType.Pointer(TemplateTag.M3GM), "BaseGeometry"), + new Field(MetaType.Padding(4)), // ls data + new Field(MetaType.Enum(), "BaseGunkFlags"), + new Field(MetaType.Pointer(TemplateTag.M3GM), "ArmGeometry"), + new Field(MetaType.Enum(), "ArmGunkFlags"), + new Field(MetaType.Pointer(TemplateTag.M3GM), "WeaponGeometry"), + new Field(MetaType.Enum(), "WeaponGunkFlags"), + new Field(MetaType.Vector3, "ArmTranslation"), + new Field(MetaType.Vector3, "WeaponTranslation"), + new Field(MetaType.Array(16, new MetaStruct("TURRParticle", + new Field(MetaType.String16, "ParticleClass"), + new Field(MetaType.Padding(4)), + new Field(MetaType.Int16, "ShotFrequency"), + new Field(MetaType.Int16, "FiringModeOwner"), + new Field(MetaType.Matrix4x3, "Transform"), + new Field(MetaType.Padding(4)) + )), "Particles"), + new Field(aiFiringMode, "FiringMode"), + new Field(aiTargeting, "Targeting"), + new Field(aiWeaponSkill, "WeaponSkill"), + new Field(MetaType.Int32, "Timeout"), + new Field(MetaType.Float, "MinElevation"), + new Field(MetaType.Float, "MaxElevation"), + new Field(MetaType.Float, "MinAzimuth"), + new Field(MetaType.Float, "MaxAzimuth"), + new Field(MetaType.Float, "MaxVerticalSpeed"), + new Field(MetaType.Float, "MaxHorizontalSpeed"), + new Field(MetaType.String32, "ActiveSound"), + new Field(MetaType.Padding(4)) + ); + + // + // Object animation template + // + + [Flags] + private enum OBANFlags : uint + { + None = 0x00, + NormalLoop = 0x01, + BackToBackLoop = 0x02, + RandomStartFrame = 0x04, + Autostart = 0x08, + ZAxisUp = 0x10 + } + + private static readonly MetaStruct oban = new MetaStruct("OBANInstance", + new Field(MetaType.Padding(12)), + new Field(MetaType.Enum(), "Flags"), + new Field(MetaType.Matrix4x3, "InitialTransform"), + new Field(MetaType.Matrix4x3, "BaseTransform"), + new Field(MetaType.Int16, "FrameLength"), + new Field(MetaType.Int16, "FrameCount"), + new Field(MetaType.Int16, "HalfStopFrame"), + new Field(MetaType.ShortVarArray(new MetaStruct("OBANKeyFrame", + new Field(MetaType.Quaternion, "Rotation"), + new Field(MetaType.Vector3, "Translation"), + new Field(MetaType.Int32, "Time") + )), "KeyFrames") + ); + + [Flags] + public enum OBOAFlags : uint + { + None = 0, + InUse = 0x0200, + NoCollision = 0x0400, + NoGravity = 0x0800, + FaceCollision = 0x1000, + } + + public enum OBOAPhysics : uint + { + None = 0, + Static = 1, + Linear = 2, + Animated = 3, + Newton = 4 + } + + // + // Starting Object Array template + // + + private static readonly MetaStruct oboa = new MetaStruct("OBOAInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(new MetaStruct("OBOAObject", + new Field(MetaType.Pointer(TemplateTag.M3GA), "Geometry"), + new Field(MetaType.Pointer(TemplateTag.OBAN), "Animation"), + new Field(MetaType.Pointer(TemplateTag.ENVP), "Particle"), + new Field(MetaType.Enum(), "Flags"), + new Field(MetaType.Int32, "DoorGunkId"), + new Field(MetaType.Int32, "DoorId"), + new Field(MetaType.Enum(), "PhysicsType"), + new Field(MetaType.Int32, "ScriptId"), + new Field(MetaType.Vector3, "Position"), + new Field(MetaType.Quaternion, "Rotation"), + new Field(MetaType.Float, "Scale"), + new Field(MetaType.Matrix4x3, "Transform"), + new Field(MetaType.String64, "Name"), + new Field(MetaType.Padding(64)) + )), "Objects") + ); + + // + // Character Body Part Impacts template + // + + private static readonly MetaStruct cbpi = new MetaStruct("CBPIInstance", + new Field(MetaType.Array(19, MetaType.Pointer(TemplateTag.Impt)), "HitImpacts"), + new Field(MetaType.Array(19, MetaType.Pointer(TemplateTag.Impt)), "BlockedImpacts"), + new Field(MetaType.Array(19, MetaType.Pointer(TemplateTag.Impt)), "KilledImpacts") + ); + + // + // Character Body Part Material template + // + + private static readonly MetaStruct cbpm = new MetaStruct("CBPMInstance", + new Field(MetaType.Array(19, MetaType.Pointer(TemplateTag.Mtrl)), "Materials") + ); + + // + // Oni Character Class template + // + + [Flags] + public enum AICharacterFlags : uint + { + None = 0x00, + NoStartleAnim = 0x01, + EnableMeleeFireDodge = 0x02, + ShootDodge = 0x04, + RunAwayDodge = 0x08, + NotUsed = 0x10 + } + + private static readonly MetaStruct oncc = new MetaStruct("ONCCInstance", + new Field(new MetaStruct("ONCCAirConstants", + new Field(MetaType.Float, "FallGravity"), + new Field(MetaType.Float, "JumpGravity"), + new Field(MetaType.Float, "JumpStartVelocity"), + new Field(MetaType.Float, "MaxVelocity"), + new Field(MetaType.Float, "JetpackAcceleration"), + new Field(MetaType.UInt16, "FramesFallGravity"), + new Field(MetaType.UInt16, "JetpackTimer"), + new Field(MetaType.Float, "MaxNoDamageFallingHeight"), + new Field(MetaType.Float, "MaxDamageFallingHeight")), + "AirConstants"), + + new Field(new MetaStruct("ONCCShadowConstants", + new Field(MetaType.Pointer(TemplateTag.TXMP), "Texture"), + new Field(MetaType.Float, "MaxHeight"), + new Field(MetaType.Float, "FadeHeight"), + new Field(MetaType.Float, "SizeMax"), + new Field(MetaType.Float, "SizeFade"), + new Field(MetaType.Float, "SizeMin"), + new Field(MetaType.Int16, "AlphaMax"), + new Field(MetaType.Int16, "AlphaFade")), + "ShadowConstants"), + + new Field(new MetaStruct("ONCCJumpConstants", + new Field(MetaType.Float, "JumpDistance"), + new Field(MetaType.Byte, "JumpHeight"), + new Field(MetaType.Byte, "JumpDistanceSquares"), + new Field(MetaType.Padding(2))), + "JumpConstants"), + + new Field(new MetaStruct("ONCCCoverConstants", + new Field(MetaType.Float, "RayIncrement"), + new Field(MetaType.Float, "RayMax"), + new Field(MetaType.Float, "RayAngle"), + new Field(MetaType.Float, "RayAngleMax")), + "CoverConstants"), + + new Field(new MetaStruct("ONCCAutoFreezeConstants", + new Field(MetaType.Float, "DistanceXZ"), + new Field(MetaType.Float, "DistanceY")), + "AutoFreezeConstants"), + + new Field(new MetaStruct("ONCCInventoryConstants", + new Field(MetaType.Int16, "HypoRegenerationRate"), + new Field(MetaType.Padding(2))), + "InventoryConstants"), + + new Field(MetaType.Array(5, MetaType.Float), "LODConstants"), + + new Field(new MetaStruct("ONCCHurtSoundConstants", + new Field(MetaType.Int16, "BasePercentage"), + new Field(MetaType.Int16, "MaxPercentage"), + new Field(MetaType.Int16, "PercentageThreshold"), + new Field(MetaType.Int16, "Timer"), + new Field(MetaType.Int16, "MinTimer"), + new Field(MetaType.Int16, "MaxLight"), + new Field(MetaType.Int16, "MaxMedium"), + new Field(MetaType.Int16, "DeathChance"), + new Field(MetaType.Int16, "VolumeTreshold"), + new Field(MetaType.Int16, "MediumTreshold"), + new Field(MetaType.Int16, "HeavyTreshold"), + new Field(MetaType.Padding(2)), + new Field(MetaType.Float, "MinVolume"), + new Field(MetaType.String32, "LightSound"), + new Field(MetaType.String32, "MediumSound"), + new Field(MetaType.String32, "HeavySound"), + new Field(MetaType.String32, "DeathSound"), + new Field(MetaType.Padding(16))), + "HurtSoundConstants"), + + new Field(new MetaStruct("ONCCAIConstants", + new Field(MetaType.Enum(), "Flags"), + new Field(MetaType.Float, "RotationSpeed"), // turning_nimbleness + new Field(MetaType.UInt16, "DazedMinFrames"), + new Field(MetaType.UInt16, "DazedMaxFrames"), + new Field(MetaType.Int32, "DodgeReactFrames"), + new Field(MetaType.Float, "DodgeTimeScale"), + new Field(MetaType.Float, "DodgeWeightScale"), + new Field(aiTargeting, "Targeting"), + new Field(MetaType.Array(13, aiWeaponSkill), "WeaponSkills"), + new Field(MetaType.Int32, "DeadMakeSureDelay"), + new Field(MetaType.Int32, "InvestigateBodyDelay"), + new Field(MetaType.Int32, "LostContactDelay"), + new Field(MetaType.Int32, "DeadTauntChance"), + new Field(MetaType.Int32, "GoForGunChance"), + new Field(MetaType.Int32, "RunPickupChance"), + new Field(MetaType.Int16, "CombatId"), + new Field(MetaType.Int16, "MeleeId"), + new Field(aiSoundConstants, "SoundConstants"), + new Field(aiVisionConstants, "VisionConstants"), + new Field(MetaType.Int32, "HostileThreatDefiniteTimer"), + new Field(MetaType.Int32, "HostileThreatStrongTimer"), + new Field(MetaType.Int32, "HostileThreatWeakTimer"), + new Field(MetaType.Int32, "FriendlyThreatDefiniteTimer"), + new Field(MetaType.Int32, "FriendlyThreatStrongTimer"), + new Field(MetaType.Int32, "FriendlyThreatWeakTimer"), + new Field(MetaType.Float, "EarshotRadius")), + "AIConstants"), + + new Field(MetaType.Pointer(TemplateTag.ONCV), "Variant"), + new Field(MetaType.Pointer(TemplateTag.ONCP), "Particles"), + new Field(MetaType.Pointer(TemplateTag.ONIA), "Impacts"), + new Field(MetaType.Padding(4)), + new Field(MetaType.String16, "ImpactModifierName"), + + new Field(MetaType.Array(15, new MetaStruct("ONCCImpact", + new Field(MetaType.String128, "Name"), + new Field(MetaType.Padding(2, 0xff)) + )), "Impacts"), + + new Field(MetaType.Padding(2)), + new Field(MetaType.String64, "DeathParticle"), + + new Field(MetaType.Padding(8)), + new Field(MetaType.Pointer(TemplateTag.TRBS), "BodySet"), + new Field(MetaType.Pointer(TemplateTag.TRMA), "BodyTextures"), + new Field(MetaType.Pointer(TemplateTag.CBPM), "BodyMaterials"), + new Field(MetaType.Pointer(TemplateTag.CBPI), "BodyImpacts"), + new Field(MetaType.Int32, "FightModeTimer"), + new Field(MetaType.Int32, "IdleAnimation1Timer"), + new Field(MetaType.Int32, "IdleAnimation2Timer"), + new Field(MetaType.Int32, "Health"), + new Field(MetaType.Enum(), "FeetBones"), + + new Field(MetaType.Float, "MinBodySizeFactor"), + new Field(MetaType.Float, "MaxBodySizeFactor"), + new Field(MetaType.Array(7, MetaType.Float), "DamageFactors"), + new Field(MetaType.Float, "BossShieldProtectAmount"), + + new Field(MetaType.Pointer(TemplateTag.TRAC), "Animations"), + new Field(MetaType.Pointer(TemplateTag.TRSC), "AimingScreens"), + + new Field(MetaType.UInt16, "AIRateOfFire"), + new Field(MetaType.UInt16, "DeathDeleteDelay"), + new Field(MetaType.Byte, "WeaponHand"), + new Field(MetaType.Byte, "HasDaodanPowers"), + new Field(MetaType.Byte, "HasSupershield"), + new Field(MetaType.Byte, "CantTouchThis") + ); + + // + // Oni Character Impact Array template + // + + private static readonly MetaStruct onia = new MetaStruct("ONIAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("ONIAImpact", + new Field(MetaType.String16, "Name"), + new Field(MetaType.String128, "Type"), + new Field(MetaType.String16, "Modifier"), + new Field(MetaType.Padding(2, 0xff)), + new Field(MetaType.Padding(2)) + )), "Impacts") + ); + + // + // Oni Character Particle Array template + // + + public enum ONCPBodyPart : ushort + { + Pelvis, + LeftThigh, + LeftCalf, + LeftFoot, + RightThigh, + RightCalf, + RightFoot, + Mid, + Chest, + Neck, + Head, + LeftShoulder, + LeftArm, + LeftWrist, + LeftFist, + RightShoulder, + RightArm, + RightWrist, + RightFist, + KillImpact = 0x8000, + None = 0xffff + } + + private static readonly MetaStruct oncp = new MetaStruct("ONCPInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("ONCPParticle", + new Field(MetaType.String16, "Name"), + new Field(MetaType.String64, "Type"), + new Field(MetaType.Enum(), "BodyPart"), + new Field(MetaType.Padding(1, 0x5f)), + new Field(MetaType.Padding(5)) + )), "Particles") + ); + + // + // Oni Character Variant template + // + + private static readonly MetaStruct oncv = new MetaStruct("ONCVInstance", + new Field(MetaType.Pointer(TemplateTag.ONCV), "ParentVariant"), + new Field(MetaType.String32, "CharacterClass"), + new Field(MetaType.String32, "CharacterClassHard") + ); + + // + // Corpse Array template + // + + private static readonly MetaStruct crsa = new MetaStruct("CRSAInstance", + new Field(MetaType.Padding(12)), + new Field(MetaType.Int32, "FixedCount"), + new Field(MetaType.Int32, "UsedCount"), + new Field(MetaType.VarArray(new MetaStruct("CRSACorpse", + new Field(MetaType.Padding(160)), + new Field(MetaType.Pointer(TemplateTag.ONCC), "CharacterClass"), + new Field(MetaType.Array(19, MetaType.Matrix4x3), "Transforms"), + new Field(MetaType.BoundingBox, "BoundingBox") + )), "Corpses") + ); + + // + // Diary Page template + // + + private static readonly MetaStruct dpge = new MetaStruct("DPgeInstance", + new Field(MetaType.Int16, "LevelNumber"), + new Field(MetaType.Int16, "PageNumber"), + new Field(MetaType.Byte, "IsLearnedMove"), + new Field(MetaType.Padding(3)), + new Field(MetaType.Padding(48)), + new Field(MetaType.Pointer(TemplateTag.IGPG), "Page") + ); + + // + // Film template + // + + [Flags] + public enum FILMKeys : ulong + { + None = 0x00, + Escape = 0x01, + Console = 0x02, + Pause = 0x04, + Cutscene1 = 0x08, + Cutscene2 = 0x10, + F4 = 0x20, + F5 = 0x40, + F6 = 0x80, + F7 = 0x0100, + F8 = 0x0200, + StartRecord = 0x0400, + StopRecord = 0x0800, + PlayRecord = 0x1000, + F12 = 0x2000, + LookMode = 0x8000, + Screenshot = 0x010000, + Forward = 0x200000, + Backward = 0x400000, + TurnLeft = 0x800000, + TurnRight = 0x01000000, + StepLeft = 0x02000000, + StepRight = 0x04000000, + Jump = 0x08000000, + Crouch = 0x10000000, + Punch = 0x20000000, + Kick = 0x40000000, + Block = 0x80000000, + Walk = 0x0100000000, + Action = 0x0200000000, + Hypo = 0x0400000000, + Reload = 0x0800000000, + Swap = 0x1000000000, + Drop = 0x2000000000, + Fire1 = 0x4000000000, + Fire2 = 0x8000000000, + Fire3 = 0x010000000000 + } + + private static readonly MetaStruct film = new MetaStruct("FILMInstance", + new Field(MetaType.Vector3, "Position"), + new Field(MetaType.Float, "Facing"), + new Field(MetaType.Float, "DesiredFacing"), + new Field(MetaType.Float, "HeadFacing"), + new Field(MetaType.Float, "HeadPitch"), + new Field(MetaType.Int32, "FrameCount"), + new Field(MetaType.Array(2, MetaType.Pointer(TemplateTag.TRAM)), "Animations"), + new Field(MetaType.Padding(12)), + new Field(MetaType.VarArray(new MetaStruct("Frame", + new Field(MetaType.Vector2, "MouseDelta"), + new Field(MetaType.Enum(), "Keys"), + new Field(MetaType.Int32, "Frame"), + new Field(MetaType.Padding(4)) + )), "Frames") + ); + + // + // Oni Game Settings template + // + + private static readonly MetaStruct ongs = new MetaStruct("ONGSInstance", + new Field(MetaType.Float, "MaxOverhealthFactor"), + new Field(MetaType.Float, "NormalHypoStrength"), + new Field(MetaType.Float, "OverhealthHypoStrength"), + new Field(MetaType.Float, "OverhealthMinDamage"), + new Field(MetaType.Float, "OverhealthMaxDamage"), + + new Field(MetaType.Int32, "UsedHealthElements"), + new Field(MetaType.Array(16, MetaType.Float), "HealthPercent"), + new Field(MetaType.Array(16, MetaType.Color), "HealthColor"), + + new Field(MetaType.Array(6, MetaType.String128), "PowerupModels"), + new Field(MetaType.Padding(128)), + new Field(MetaType.Array(6, MetaType.String128), "PowerupGlowTextures"), + new Field(MetaType.Padding(128)), + new Field(MetaType.Array(6, MetaType.Vector2), "PowerupGlowSizes"), + new Field(MetaType.Padding(8)), + + new Field(MetaType.Array(23, MetaType.String32), "Sounds"), + + new Field(MetaType.Array(3, MetaType.Float), "NoticeFactors"), + new Field(MetaType.Array(3, MetaType.Float), "BlockChanceFactors"), + new Field(MetaType.Array(3, MetaType.Float), "DodgeFactors"), + new Field(MetaType.Array(3, MetaType.Float), "WeaponAccuracyFactors"), + new Field(MetaType.Array(3, MetaType.Float), "EnemyHealthFactors"), + new Field(MetaType.Array(3, MetaType.Float), "PlayerHealthFactors"), + + new Field(MetaType.Int32, "UsedAutoPrompts"), + new Field(MetaType.Array(16, new MetaStruct("ONGSAutoPrompt", + new Field(MetaType.String32, "Notes"), + new Field(MetaType.Int16, "FirstAutopromptLevel"), + new Field(MetaType.Int16, "LastAutopromptLevel"), + new Field(MetaType.String32, "SubtitleName") + )), "AutoPrompts") + ); + + // + // Help Page template + // + + private static readonly MetaStruct hpge = new MetaStruct("HPgeInstance", + new Field(MetaType.Padding(4)), + new Field(MetaType.Pointer(TemplateTag.IGPG), "Page") + ); + + // + // IGUI HUD Help template + // + + private static readonly MetaStruct ighh = new MetaStruct("IGHHInstance", + new Field(MetaType.Padding(28)), + new Field(MetaType.Pointer(TemplateTag.TXMP), "LeftTexture"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "RightTexture"), + new Field(MetaType.Int16, "LeftX"), + new Field(MetaType.Int16, "LeftY"), + new Field(MetaType.Int16, "RightX"), + new Field(MetaType.Int16, "RightY"), + new Field(MetaType.Int32, "LeftCount"), + new Field(MetaType.Int32, "RightCount"), + new Field(MetaType.VarArray(new MetaStruct("IGHHLabels", + new Field(MetaType.String64, "Text"), + new Field(MetaType.Int16, "X"), + new Field(MetaType.Int16, "Y") + )), "Labels") + ); + + // + // IGUI Page template + // + + private enum IGPGFontStyle : uint + { + Normal = 0, + Bold = 1, + Italic = 2 + } + + [Flags] + private enum IGPGFlags : ushort + { + None = 0x00, + Family = 0x01, + Style = 0x02, + Color = 0x04, + Size = 0x08 + } + + private static readonly MetaStruct igpg = new MetaStruct("IGPGInstance", + new Field(new MetaStruct("IGPGFont", + new Field(MetaType.Pointer(TemplateTag.TSFF), "Family"), + new Field(MetaType.Enum(), "Style"), + new Field(MetaType.Color, "Color"), + new Field(MetaType.UInt16, "Size"), + new Field(MetaType.Enum(), "Flags")), + "Font"), + new Field(MetaType.Pointer(TemplateTag.NONE), "Image"), + new Field(MetaType.Pointer(TemplateTag.IGSA), "Text1"), + new Field(MetaType.Pointer(TemplateTag.IGSA), "Text2") + ); + + // + // IGUI Page Array template + // + + private static readonly MetaStruct igpa = new MetaStruct("IGPAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(MetaType.Pointer(TemplateTag.IGPG)), "Pages") + ); + + // + // IGUI String template + // + + private enum IGStFontStyle : uint + { + Normal = 0, + Bold = 1, + Italic = 2 + } + + [Flags] + private enum IGStFlags : ushort + { + None = 0x00, + Family = 0x01, + Style = 0x02, + Color = 0x04, + Size = 0x08 + } + + private static readonly MetaStruct igst = new MetaStruct("IGStInstance", + new Field(new MetaStruct("IGStFont", + new Field(MetaType.Pointer(TemplateTag.TSFF), "Family"), + new Field(MetaType.Enum(), "Style"), + new Field(MetaType.Color, "Color"), + new Field(MetaType.Int16, "Size"), + new Field(MetaType.Enum(), "Flags")), + "Font"), + new Field(MetaType.String(384), "Text") + ); + + // + // IGUI String Array template + // + + private static readonly MetaStruct igsa = new MetaStruct("IGSAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(MetaType.Pointer(TemplateTag.IGSt)), "Strings") + ); + + // + // Item Page template + // + + private static readonly MetaStruct ipge = new MetaStruct("IPgeInstance", + new Field(MetaType.Int32, "PageNumber"), + new Field(MetaType.Pointer(TemplateTag.IGPG), "Page") + ); + + // + // Key Icons template + // + + private static readonly MetaStruct keyi = new MetaStruct("KeyIInstance", + new Field(MetaType.Pointer(TemplateTag.TXMP), "Punch"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Kick"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Forward"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Backward"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Left"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Right"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Crouch"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Jump"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Hold"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Plus") + ); + + // + // Oni Game Level template + // + + private static readonly MetaStruct onlv = new MetaStruct("ONLVInstance", + new Field(MetaType.String64, "Name"), + new Field(MetaType.Pointer(TemplateTag.AKEV), "Environment"), + new Field(MetaType.Pointer(TemplateTag.OBOA), "Objects"), + new Field(MetaType.Padding(12)), + new Field(MetaType.Pointer(TemplateTag.ONSK), "SkyBox"), + new Field(MetaType.Padding(4)), + new Field(MetaType.Pointer(TemplateTag.AISA), "Characters"), + new Field(MetaType.Padding(12)), + new Field(MetaType.Pointer(TemplateTag.ONOA), "ObjectQuadMap"), + new Field(MetaType.Pointer(TemplateTag.ENVP), "Particles"), + new Field(MetaType.Padding(644)), + new Field(MetaType.Pointer(TemplateTag.CRSA), "Corpses") + ); + + // + // Oni Game Level Descriptor template + // + + private static readonly MetaStruct onld = new MetaStruct("ONLDInstance", + new Field(MetaType.Int16, "LevelNumber"), + new Field(MetaType.Int16, "NextLevelNumber"), + new Field(MetaType.String64, "DisplayName") + ); + + // + // Object Gunk Array template + // + + private static readonly MetaStruct onoa = new MetaStruct("ONOAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("ONOAElement", + new Field(MetaType.Int32, "ObjectId"), + new Field(MetaType.Pointer(TemplateTag.IDXA), "QuadList") + )), "Elements") + ); + + // + // Objective Page template + // + + private static readonly MetaStruct opge = new MetaStruct("OPgeInstance", + new Field(MetaType.Padding(2)), + new Field(MetaType.UInt16, "LevelNumber"), + new Field(MetaType.Pointer(TemplateTag.IGPA), "Pages") + ); + + // + // Oni Sky class template + // + + private static readonly MetaStruct onsk = new MetaStruct("ONSKInstance", + new Field(MetaType.Array(6, MetaType.Pointer(TemplateTag.TXMP)), "SkyboxTextures"), + new Field(MetaType.Array(8, MetaType.Pointer(TemplateTag.TXMP)), "Planets"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "SunFlare"), + new Field(MetaType.Array(5, MetaType.Pointer(TemplateTag.TXMP)), "Stars"), + new Field(MetaType.Int32, "PlanetCount"), + new Field(MetaType.Int32, "NoSunFlare"), + new Field(MetaType.Array(8, MetaType.Float), "PlanetWidths"), + new Field(MetaType.Array(8, MetaType.Float), "PlanetHeights"), + new Field(MetaType.Array(8, MetaType.Float), "PlanetElevations"), + new Field(MetaType.Array(8, MetaType.Float), "PlanetAzimuths"), + new Field(MetaType.Float, "SunFlareSize"), + new Field(MetaType.Float, "SunFlareIntensity"), + new Field(MetaType.Int32, "StarCount"), + new Field(MetaType.Int32, "RandomSeed"), + new Field(MetaType.Int32, "") + ); + + // + // Text Console template + // + + private static readonly MetaStruct txtc = new MetaStruct("TxtCInstance", + new Field(MetaType.Pointer(TemplateTag.IGPA), "Pages") + ); + + // + // Oni Variant List template + // + + private static readonly MetaStruct onvl = new MetaStruct("ONVLInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(MetaType.Pointer(TemplateTag.ONCV)), "Variants") + ); + + // + // Weapon Page template + // + + private static readonly MetaStruct wpge = new MetaStruct("WPgeInstance", + new Field(MetaType.Pointer(TemplateTag.ONWC), "WeaponClass"), + new Field(MetaType.Pointer(TemplateTag.IGPG), "Page") + ); + + // + // Part Specification template + // + + private static readonly MetaStruct pspc = new MetaStruct("PSpcInstance", + new Field(MetaType.Array(9, new MetaStruct("PSpcPoint", + new Field(MetaType.Int16, "X"), + new Field(MetaType.Int16, "Y") + )), "LeftTop"), + new Field(MetaType.Array(9, new MetaStruct("PSpcPoint", + new Field(MetaType.Int16, "X"), + new Field(MetaType.Int16, "Y") + )), "RightBottom"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Texture") + ); + + // + // Part Specification List template + // + + private enum PSpLType : uint + { + OutOfGameBackground = 0, + InGameBackground = 1, + SoundDebugPanelBackground = 5 + } + + private static readonly MetaStruct pspl = new MetaStruct("PSpLInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("PSpLElement", + new Field(MetaType.Enum(), "Type"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Part") + )), "Elements") + ); + + // + // Part Specifications UI template + // + + private static readonly MetaStruct psui = new MetaStruct("PSUIInstance", + new Field(MetaType.Pointer(TemplateTag.PSpc), "Background"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Border"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Title"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Grow"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "CloseIdle"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ClosePressed"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ZoomIdle"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ZoomPressed"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "FlattenIdle"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "FlattenPressed"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "TextCaret"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Outline"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Button"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ButtonOff"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ButtonOn"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "CheckBoxOn"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "CheckBoxOff"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "EditField"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "EditFieldFocused"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "EditFieldHighlighted"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Divider"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Check"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "PopupMenu"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ProgressBarTrack"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ProgressBarFill"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "RadioButtonOn"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "RadioButtonOff"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarArrowUpIdle"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarArrowUpPressed"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarArrowDownIdle"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarArrowDownPressed"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarVerticalTrack"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarArrowLeftIdle"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarArrowLeftPressed"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarArrowRightIdle"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarArrorRightPressed"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarHorizontalTrack"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "ScrollBarThumb"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "SliderThumb"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "SliderTrack"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Background2"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Background3"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "File"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Folder") + ); + + // + // Subtitle Array template + // + + private static readonly MetaStruct subt = new MetaStruct("SUBTInstance", + new Field(MetaType.Padding(16)), + new BinaryPartField(MetaType.RawOffset, "DataOffset"), + new Field(MetaType.VarArray(MetaType.Int32), "Elements") + ); + + // + // Index Array template + // + + private static readonly MetaStruct idxa = new MetaStruct("IDXAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(MetaType.Int32), "Indices") + ); + + // + // Totoro Aiming Screen template + // + + private static readonly MetaStruct tras = new MetaStruct("TRASInstance", + new Field(MetaType.Pointer(TemplateTag.TRAM), "Animation"), + new Field(MetaType.Float, "LeftStep"), + new Field(MetaType.Float, "RightStep"), + new Field(MetaType.UInt16, "LeftFrames"), + new Field(MetaType.UInt16, "RightFrames"), + new Field(MetaType.Float, "DownStep"), + new Field(MetaType.Float, "UpStep"), + new Field(MetaType.UInt16, "DownFrames"), + new Field(MetaType.UInt16, "UpFrames") + ); + + // + // Totoro Animation Sequence template + // + + public enum TRAMType : ushort + { + None, + Anything, + Walk, + Run, + Slide, + Jump, + Stand, + StandingTurnLeft, + StandingTurnRight, + RunBackwards, + RunSidestepLeft, + RunSidestepRight, + Kick, + WalkSidestepLeft, + WalkSidestepRight, + WalkBackwards, + Stance, + Crouch, + JumpForward, + JumpBackward, + JumpLeft, + JumpRight, + Punch, + Block, + Land, + Fly, + KickForward, + KickLeft, + KickRight, + KickBack, + KickLow, + PunchForward, + PunchLeft, + PunchRight, + PunchBack, + PunchLow, + Kick2, + Kick3, + Punch2, + Punch3, + LandForward, + LandRight, + LandLeft, + LandBack, + PPK, + PKK, + PKP, + KPK, + KPP, + KKP, + PK, + KP, + PunchHeavy, + KickHeavy, + PunchForwardHeavy, + KickForwardHeavy, + AimingOverlay, + HitOverlay, + CrouchRun, + CrouchWalk, + CrouchRunBackwards, + CrouchWalkBackwards, + CrouchRunSidestepLeft, + CrouchRunSidestepRight, + CrouchWalkSidestepLeft, + CrouchWalkSidestepRight, + RunKick, + RunPunch, + RunBackPunch, + RunBackKick, + SidestepLeftKick, + SidestepLeftPunch, + SidestepRightKick, + SidestepRightPunch, + Prone, + Flip, + HitHead, + HitBody, + HitFoot, + KnockdownHead, + KnockdownBody, + KnockdownFoot, + HitCrouch, + KnockdownCrouch, + HitFallen, + HitHeadBehind, + HitBodyBehind, + HitFootBehind, + KnockdownHeadBehind, + KnockdownBodyBehind, + KnockdownFootBehind, + HitCrouchBehind, + KnockdownCrouchBehind, + Idle, + Taunt, + Throw, + Thrown1, + Thrown2, + Thrown3, + Thrown4, + Thrown5, + Thrown6, + Special1, + Special2, + Special3, + Special4, + ThrowForwardPunch, + ThrowForwardKick, + ThrowBackwardPunch, + ThrowBackwardKick, + RunThrowForwardPunch, + RunThrowBackwardPunch, + RunThrowForwardKick, + RunThrowBackwardKick, + Thrown7, + Thrown8, + Thrown9, + Thrown10, + Thrown11, + Thrown12, + StartleLeft, + StartleRight, + Sit, + StandSpecial, + Act, + Kick3Fw, + HitFootOuch, + HitJewels, + Thrown13, + Thrown14, + Thrown15, + Thrown16, + Thrown17, + PPKK, + PPKKK, + PPKKKK, + LandHard, + LandHardForward, + LandHardRight, + LandHardLeft, + LandHardBack, + LandDead, + CrouchTurnLeft, + CrouchTurnRight, + CrouchForward, + CrouchBack, + CrouchLeft, + CrouchRight, + GetupKickBack, + AutopistolRecoil, + PhaseRifleRecoil, + PhaseStreamRecoil, + SuperballRecoil, + VandegrafRecoil, + ScramCannonRecoil, + MercuryBowRecoil, + ScreamerRecoil, + PickupObject, + PickupPistol, + PickupRifle, + Holster, + DrawPistol, + DrawRifle, + Punch4, + ReloadPistol, + ReloadPhaseRifle, + ReloadPhaseStream, + ReloadSuperball, + ReloadVandegraf, + ReloadScramCannon, + ReloadMercuryBow, + ReloadScreamer, + PfPf, + PfPfPf, + PlPl, + PlPlPl, + PrPr, + PrPrPr, + PbPb, + PbPbPb, + PdPd, + PdPdPd, + KfKf, + KfKfKf, + KlKl, + KlKlKl, + KrKr, + KrKrKr, + KbKb, + KbKbKb, + KdKd, + KdKdKd, + StartleLt, + StartleRt, + StartleBk, + StartleFw, + Console, + ConsoleWalk, + Stagger, + Watch, + ActNo, + ActYes, + ActTalk, + ActShrug, + ActShout, + ActGive, + RunStop, + WalkStop, + RunStart, + WalkStart, + RunBackwardsStart, + WalkBackwardsStart, + Stun, + StaggerBehind, + Blownup, + BlownupBehind, + OneStepStop, + RunSidestepLeftStart, + RunSidestepRightStart, + Powerup, + FallingFlail, + ConsolePunch, + TeleportIn, + TeleportOut, + NinjaFireball, + NinjaInvisible, + PunchRifle, + PickupObjectMid, + PickupPistolMid, + PickupRifleMid, + Hail, + MuroThunderbolt, + HitOverlayAI + } + + [Flags] + public enum TRAMFootstepType + { + None = 0, + Left = 1, + Right = 2 + } + + [Flags] + public enum TRAMAttackFlags + { + None = 0, + Unblockable = 1, + High = 2, + Low = 4, + HalfDamage = 8 + } + + [Flags] + public enum TRAMVarient + { + None = 0x0000, + Sprint = 0x0100, + Combat = 0x0200, + RightPistol = 0x0800, + LeftPistol = 0x1000, + RightRifle = 0x2000, + LeftRifle = 0x4000, + Panic = 0x8000 + } + + [Flags] + public enum TRAMBoneFlags : uint + { + None = 0x0000, + Pelvis = 0x0001, + LeftThigh = 0x0002, + LeftCalf = 0x0004, + LeftFoot = 0x0008, + RightThigh = 0x0010, + RightCalf = 0x0020, + RightFoot = 0x0040, + Mid = 0x0080, + Chest = 0x0100, + Neck = 0x0200, + Head = 0x0400, + LeftShoulder = 0x0800, + LeftArm = 0x1000, + LeftWrist = 0x2000, + LeftFist = 0x4000, + RightShoulder = 0x8000, + RightArm = 0x10000, + RightWrist = 0x20000, + RightFist = 0x40000 + } + + public enum TRAMBone + { + Pelvis, + LeftThigh, + LeftCalf, + LeftFoot, + RightThigh, + RightCalf, + RightFoot, + Mid, + Chest, + Neck, + Head, + LeftShoulder, + LeftArm, + LeftWrist, + LeftFist, + RightShoulder, + RightArm, + RightWrist, + RightFist + } + + public enum TRAMDirection + { + None, + Forward, + Backward, + Left, + Right + } + + [Flags] + public enum TRAMFlags + { + RuntimeLoaded = 0x00000001, + Invulnerable = 0x00000002, + BlockHigh = 0x00000004, + BlockLow = 0x00000008, + Attack = 0x00000010, + DropWeapon = 0x00000020, + InAir = 0x00000040, + Atomic = 0x00000080, + + NoTurn = 0x00000100, + AttackForward = 0x00000200, + AttackLeft = 0x00000400, + AttackRight = 0x00000800, + AttackBackward = 0x00001000, + Overlay = 0x00002000, + DontInterpolateVelocity = 0x00004000, + ThrowSource = 0x00008000, + + ThrowTarget = 0x00010000, + RealWorld = 0x00020000, + DoAim = 0x00040000, + DontAim = 0x00080000, + CanPickup = 0x00100000, + Aim360 = 0x00200000, + DisableShield = 0x00400000, + NoAIPickup = 0x00800000 + } + + public enum TRAMState + { + None, + Anything, + RunningLeftDown, + RunningRightDown, + Sliding, + WalkingLeftDown, + WalkingRightDown, + Standing, + RunStart, + RunAccel, + RunSidestepLeft, + RunSidestepRight, + RunSlide, + RunJump, + RunJumpLand, + RunBackStart, + RunningBackRightDown, + RunningBackLeftDown, + FallenBack, + Crouch, + RunningUpstairRightDown, + RunningUpstairLeftDown, + SidestepLeftLeftDown, + SidestepLeftRightDown, + SidestepRightLeftDown, + SidestepRightRightDown, + SidestepRightJump, + SidestepLeftJump, + JumpForward, + JumpUp, + RunBackSlide, + LieBack, + SsLtStart, + SsRtStart, + WalkingSidestepLeft, + CrouchWalk, + WalkingSidestepRight, + Flying, + Falling, + FlyingForward, + FallingForward, + FlyingBack, + FallingBack, + FlyingLeft, + FallingLeft, + FlyingRight, + FallingRight, + CrouchStart, + WalkingBackLeftDown, + WalkingBackRightDown, + FallenFront, + SidestepLeftStart, + SidestepRightStart, + Sit, + PunchLow, + StandSpecial, + Acting, + CrouchRunLeft, + CrouchRunRight, + CrouchRunBackLeft, + CrouchRunBackRight, + Blocking1, + Blocking2, + Blocking3, + CrouchBlocking1, + Gliding, + WatchIdle, + Stunned, + Powerup, + Thunderbolt + } + + private static readonly MetaStruct tram = new MetaStruct("TRAMInstance", + new Field(MetaType.Padding(4)), + new BinaryPartField(MetaType.RawOffset, "Height", "FrameCount", 4, + MetaType.Float), + + new BinaryPartField(MetaType.RawOffset, "Velocity", "FrameCount", 8, + MetaType.Vector2), + + new BinaryPartField(MetaType.RawOffset, "Attack", "AttackCount", 32, new MetaStruct("TRAMAttack", + new Field(MetaType.Int32, "Bones"), + new Field(MetaType.Float, "Unknown1"), + new Field(MetaType.Int32, "Flags"), + new Field(MetaType.Int16, "HitPoints"), + new Field(MetaType.Int16, "StartFrame"), + new Field(MetaType.Int16, "EndFrame"), + new Field(MetaType.Int16, "AnimationType"), + new Field(MetaType.Int16, "Unknown2"), + new Field(MetaType.Int16, "BlockStun"), + new Field(MetaType.Int16, "Stagger"), + new Field(MetaType.Padding(6)))), + + new BinaryPartField(MetaType.RawOffset, "Damage", "DamageCount", 4, new MetaStruct("TRAMDamage", + new Field(MetaType.Int16, "Damage"), + new Field(MetaType.Int16, "Frame"))), + + new BinaryPartField(MetaType.RawOffset, "MotionBlur", "MotionBlurCount", 12, new MetaStruct("TRAMMotionBlur", + new Field(MetaType.Int32, "Bones"), + new Field(MetaType.Int16, "StartFrame"), + new Field(MetaType.Int16, "EndFrame"), + new Field(MetaType.Byte, "Lifetime"), + new Field(MetaType.Byte, "Alpha"), + new Field(MetaType.Byte, "Interval"), + new Field(MetaType.Padding(1)))), + + new BinaryPartField(MetaType.RawOffset, "Shortcut", "ShortcutCount", 8, new MetaStruct("TRAMShortcut", + new Field(MetaType.Int16, "FromState"), + new Field(MetaType.Byte, "Length"), + new Field(MetaType.Padding(1)), + new Field(MetaType.Int32, "Flags"))), + + new BinaryPartField(MetaType.RawOffset, "Throw", 22, new MetaStruct("TRAMThrow", + new Field(MetaType.Vector3, "PositionAdjustment"), + new Field(MetaType.Float, "AngleAdjustment"), + new Field(MetaType.Float, "Distance"), + new Field(MetaType.Int16, "Type"))), + + new BinaryPartField(MetaType.RawOffset, "Footstep", "FootstepCount", 4, new MetaStruct("TRAMFootstep", + new Field(MetaType.Int16, "Frame"), + new Field(MetaType.Int16, "Type"))), + + new BinaryPartField(MetaType.RawOffset, "Particle", "ParticleCount", 24, new MetaStruct("TRAMParticle", + new Field(MetaType.Int16, "StartFrame"), + new Field(MetaType.Int16, "EndFrame"), + new Field(MetaType.Int32, "Bone"), + new Field(MetaType.String16, "Name"))), + + new BinaryPartField(MetaType.RawOffset, "Position", "FrameCount", 8, new MetaStruct("TRAMPosition", + new Field(MetaType.Int16, "X"), + new Field(MetaType.Int16, "Z"), + new Field(MetaType.Int16, "Height"), + new Field(MetaType.Int16, "Y"))), + + new BinaryPartField(MetaType.RawOffset, "Rotation"), + + new BinaryPartField(MetaType.RawOffset, "Sound", "SoundDataCount", 34, new MetaStruct("TRAMSound", + new Field(MetaType.String32, "SoundName"), + new Field(MetaType.Int16, "StartFrame"))), + + new Field(MetaType.Int32, "Flags"), + new Field(MetaType.Array(2, MetaType.Pointer(TemplateTag.TRAM)), "DirectAnimations"), + new Field(MetaType.Int32, "OverlayUsedParts"), + new Field(MetaType.Int32, "OverlayReplacedParts"), + new Field(MetaType.Float, "FinalRotation"), + new Field(MetaType.Int16, "MoveDirection"), + new Field(MetaType.Int16, "AttackSoundIndex"), + new Field(new MetaStruct("TRAMExtentInfo", + new Field(MetaType.Float, "MaxHorizontal"), + new Field(MetaType.Float, "MinY"), + new Field(MetaType.Float, "MaxY"), + new Field(MetaType.Array(36, MetaType.Float), "Horizontal"), + new Field(new MetaStruct("TRAMExtent", + new Field(MetaType.Int16, "Frame"), + new Field(MetaType.Byte, "Attack"), + new Field(MetaType.Byte, "FrameOffset"), + new Field(MetaType.Vector3, "Location"), + new Field(MetaType.Float, "Length"), + new Field(MetaType.Float, "MinY"), + new Field(MetaType.Float, "MaxY"), + new Field(MetaType.Float, "Angle")), + "FirstExtent"), + new Field(new MetaStruct("TRAMExtent", + new Field(MetaType.Int16, "Frame"), + new Field(MetaType.Byte, "Attack"), + new Field(MetaType.Byte, "FrameOffset"), + new Field(MetaType.Vector3, "Location"), + new Field(MetaType.Float, "Length"), + new Field(MetaType.Float, "MinY"), + new Field(MetaType.Float, "MaxY"), + new Field(MetaType.Float, "Angle")), + "MaxExtent"), + new Field(MetaType.Int32, "AlternateMoveDirection"), + new Field(MetaType.Int32, "ExtentCount"), + new BinaryPartField(MetaType.RawOffset, "Extents", "ExtentCount", 12, new MetaStruct("TRAMExtent", + new Field(MetaType.Int16, "Frame"), + new Field(MetaType.Int16, "Angle"), + new Field(MetaType.Int16, "Length"), + new Field(MetaType.Int16, "Offset"), + new Field(MetaType.Int16, "MinY"), + new Field(MetaType.Int16, "MaxY")))), + "ExtentInfo"), + new Field(MetaType.String16, "ImpactParticle"), + new Field(MetaType.Int16, "HardPause"), + new Field(MetaType.Int16, "SoftPause"), + new Field(MetaType.Int32, "SoundDataCount"), + new Field(MetaType.Padding(6)), + new Field(MetaType.Int16, "FramesPerSecond"), + new Field(MetaType.Int16, "CompressionSize"), + new Field(MetaType.Int16, "Type"), + new Field(MetaType.Int16, "AimingType"), + new Field(MetaType.Int16, "FromState"), + new Field(MetaType.Int16, "ToState"), + new Field(MetaType.Int16, "BodyPartCount"), + new Field(MetaType.Int16, "FrameCount"), + new Field(MetaType.Int16, "Duration"), + new Field(MetaType.Int16, "Varient"), + new Field(MetaType.Padding(2)), + new Field(MetaType.Int16, "AtomicStart"), + new Field(MetaType.Int16, "AtomicEnd"), + new Field(MetaType.Int16, "EndInterpolation"), + new Field(MetaType.Int16, "MaxInterpolation"), + new Field(MetaType.Int16, "ActionFrame"), + new Field(MetaType.Int16, "FirstLevelAvailable"), + new Field(MetaType.Byte, "InvulnerableStart"), + new Field(MetaType.Byte, "InvulnerableEnd"), + + new Field(MetaType.Byte, "AttackCount"), + new Field(MetaType.Byte, "DamageCount"), + new Field(MetaType.Byte, "MotionBlurCount"), + new Field(MetaType.Byte, "ShortcutCount"), + new Field(MetaType.Byte, "FootstepCount"), + new Field(MetaType.Byte, "ParticleCount") + ); + + // + // Animation Collection template + // + + private static readonly MetaStruct trac = new MetaStruct("TRACInstance", + new Field(MetaType.Padding(16)), + new Field(MetaType.Pointer(TemplateTag.TRAC), "ParentCollection"), + new Field(MetaType.Padding(2)), + new Field(MetaType.ShortVarArray(new MetaStruct("TRACAnimation", + new Field(MetaType.Int16, "Weight"), + new Field(MetaType.Padding(6)), + new Field(MetaType.Pointer(TemplateTag.TRAM), "Animation") + )), "Animations") + ); + + // + // Totoro Quaternion Body template + // + + private static readonly MetaStruct trcm = new MetaStruct("TRCMInstance", + new Field(MetaType.Padding(4)), + new Field(MetaType.UInt16, "BodyPartCount"), + new Field(MetaType.Padding(78)), + new Field(MetaType.Pointer(TemplateTag.TRGA), "Geometry"), + new Field(MetaType.Pointer(TemplateTag.TRTA), "Position"), + new Field(MetaType.Pointer(TemplateTag.TRIA), "Hierarchy") + ); + + // + // Totoro Body Set template + // + + private static readonly MetaStruct trbs = new MetaStruct("TRBSInstance", + new Field(MetaType.Array(5, MetaType.Pointer(TemplateTag.TRCM)), "Elements") + ); + + // + // Texture Map Array template + // + + private static readonly MetaStruct trma = new MetaStruct("TRMAInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(MetaType.Pointer(TemplateTag.TXMP)), "Textures") + ); + + // + // Totoro Quaternion Body Geometry Array template + // + + private static readonly MetaStruct trga = new MetaStruct("TRGAInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(MetaType.Pointer(TemplateTag.M3GM)), "Geometries") + ); + + // + // Totoro Quaternion Body Index Array template + // + + private static readonly MetaStruct tria = new MetaStruct("TRIAInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(new MetaStruct("TRIAElement", + new Field(MetaType.Byte, "Parent"), + new Field(MetaType.Byte, "Child"), + new Field(MetaType.Byte, "Sibling"), + new Field(MetaType.Padding(1)) + )), "Elements") + ); + + // + // Screen (aiming) Collection template + // + + private static readonly MetaStruct trsc = new MetaStruct("TRSCInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(MetaType.Pointer(TemplateTag.TRAS)), "AimingScreens") + ); + + // + // Totoro Quaternion Body Translation Array template + // + + private static readonly MetaStruct trta = new MetaStruct("TRTAInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(MetaType.Vector3), "Translations") + ); + + // + // Font template + // + + private static readonly MetaStruct tsft = new MetaStruct("TSFTInstance", + new Field(MetaType.Padding(6)), + new Field(MetaType.Int16, "FontSize"), + new Field(MetaType.Int32, "FontStyle"), + new Field(MetaType.Int16, "AscenderHeight"), + new Field(MetaType.Int16, "DescenderHeight"), + new Field(MetaType.Int16, "LeadingHeight"), + new Field(MetaType.Int16, ""), + new Field(MetaType.Array(256, MetaType.Pointer(TemplateTag.TSGA)), "Glyphs"), + new Field(MetaType.VarArray(MetaType.Int32), "GlyphBitmaps") + ); + + // + // Font Family template + // + + private static readonly MetaStruct tsff = new MetaStruct("TSFFInstance", + new Field(MetaType.Padding(16)), + new Field(MetaType.Pointer(TemplateTag.TSFL), "Language"), + new Field(MetaType.VarArray(MetaType.Pointer(TemplateTag.TSFT)), "Fonts") + ); + + // + // Font Language template + // + + private static readonly MetaStruct tsfl = new MetaStruct("TSFLInstance", + new Field(MetaType.String64, ""), + new Field(MetaType.String64, "Breaking"), + new Field(MetaType.String64, ""), + new Field(MetaType.String64, ""), + new Field(MetaType.String64, "") + ); + + // + // Glyph Array template + // + + private static readonly MetaStruct tsga = new MetaStruct("TSGAInstance", + new Field(MetaType.Array(256, new MetaStruct("TSGAGlyph", + new Field(MetaType.Int16, "Index"), + new Field(MetaType.Int16, "Width"), + new Field(MetaType.Int16, "GlyphWidth"), + new Field(MetaType.Int16, "GlyphHeight"), + new Field(MetaType.Int16, "GlyphXOrigin"), + new Field(MetaType.Int16, "GlyphYOrigin"), + new Field(MetaType.Int32, "GlyphBitmapOffset"), + new Field(MetaType.Padding(4)) + )), "Glyphs") + ); + + // + // WM Cursor List template + // + + private static readonly MetaStruct wmcl = new MetaStruct("WMCLInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("WMCLCursor", + new Field(MetaType.Int32, "Id"), + new Field(MetaType.Pointer(TemplateTag.PSpc), "Part") + )), "Cursors") + ); + + // + // WM Dialog Data template + // + + [Flags] + private enum WMDDState + { + None = 0x00, + Visible = 0x01, + Disabled = 0x02, + State04 = 0x04 + } + + [Flags] + private enum WMDDStyle : uint + { + None = 0x00, + ThinBorder = 0x01, + ThickBorder = 0x02, + TitleBar = 0x04, + Title = 0x08, + CloseButton = 0x10, + RestoreButton = 0x20, + MinimizeButton = 0x40, + Center = 0x00010000 + } + + private enum WMDDControlFontStyle : uint + { + Normal = 0, + Bold = 1, + Italic = 2 + } + + private enum WMDDControlClass : ushort + { + Desktop = 1, + Title = 3, + Button = 4, + Checkbox = 5, + Dialog = 6, + Textbox = 7, + Listbox = 8, + MenuBar = 9, + Menu = 10, + Image = 11, + Dropdown = 12, + ProgressBar = 13, + RadioButton = 14, + Slider = 17, + Label = 20 + } + + private static readonly MetaStruct wmdd = new MetaStruct("WMDDInstance", + new Field(MetaType.String256, "Caption"), + new Field(MetaType.Int16, "Id"), + new Field(MetaType.Padding(2)), + new Field(MetaType.Enum(), "State"), + new Field(MetaType.Enum(), "Style"), + new Field(MetaType.Int16, "X"), + new Field(MetaType.Int16, "Y"), + new Field(MetaType.Int16, "Width"), + new Field(MetaType.Int16, "Height"), + new Field(MetaType.VarArray(new MetaStruct("WMDDControl", + new Field(MetaType.String256, "Text"), + new Field(MetaType.Enum(), "Class"), + new Field(MetaType.Int16, "Id"), + new Field(MetaType.Int32, "State"), + new Field(MetaType.Int32, "Style"), + new Field(MetaType.Int16, "X"), + new Field(MetaType.Int16, "Y"), + new Field(MetaType.Int16, "Width"), + new Field(MetaType.Int16, "Height"), + new Field(new MetaStruct("WMDDFont", + new Field(MetaType.Pointer(TemplateTag.TSFF), "Family"), + new Field(MetaType.Enum(), "Style"), + new Field(MetaType.Color, "Color"), + new Field(MetaType.Padding(1, 1)), + new Field(MetaType.Padding(1, 0)), + new Field(MetaType.Int16, "Size")), + "Font") + )), "Controls") + ); + + // + // WM Menu Bar template + // + + private static readonly MetaStruct wmmb = new MetaStruct("WMMBInstance", + new Field(MetaType.Padding(18)), + new Field(MetaType.Int16, "Id"), + new Field(MetaType.VarArray(MetaType.Pointer(TemplateTag.WMM_)), "Items") + ); + + // + // WM Menu template + // + + private enum WMM_MenuItemType : ushort + { + Separator = 1, + Option = 2 + } + + private static readonly MetaStruct wmm_ = new MetaStruct("WMM_Instance", + new Field(MetaType.Padding(18)), + new Field(MetaType.Int16, "Id"), + new Field(MetaType.String64, "Text"), + new Field(MetaType.VarArray(new MetaStruct("WMM_MenuItem", + new Field(MetaType.Enum(), "Type"), + new Field(MetaType.Int16, "Id"), + new Field(MetaType.String64, "Text") + )), "Items") + ); + + // + // Oni Weapon Class template + // + + [Flags] + public enum ONWCFlags : uint + { + None = 0x00000000, + NoHolster = 0x00000002, + UsesCells = 0x00000004, + TwoHanded = 0x00000008, + + RecoilAffectsAiming = 0x00000010, + Automatic = 0x00000020, + StunSwitcher = 0x00000080, + + KnockdownSwitcher = 0x00000100, + Explosive = 0x00000200, + SecondaryFire = 0x00000400, + BarabbasWeapon = 0x00000800, + + Heavy = 0x00001000, + AutoRelease = 0x00002000, + HasReleaseDelay = 0x00004000, + HasLaserSight = 0x00008000, + + ScaleCrosshair = 0x00020000, + NoFade = 0x00080000, + DrainAmmo = 0x00100000 + } + + private static readonly MetaStruct onwc = new MetaStruct("ONWCInstance", + new Field(new MetaStruct("ONWCLaserSight", + new Field(MetaType.Vector3, "Origin"), + new Field(MetaType.Float, "Stiffness"), + new Field(MetaType.Float, "AdditionalAzimuth"), + new Field(MetaType.Float, "AdditionalElevation"), + new Field(MetaType.Float, "LaserMaxLength"), + new Field(MetaType.Color, "LaserColor"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "NormalTexture"), + new Field(MetaType.Color, "NormalColor"), + new Field(MetaType.Float, "NormalScale"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "LockedTexture"), + new Field(MetaType.Color, "LockedColor"), + new Field(MetaType.Float, "LockedScale"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "TunnelTexture"), + new Field(MetaType.Color, "TunnelColor"), + new Field(MetaType.Float, "TunnelScale"), + new Field(MetaType.Int32, "TunnelCount"), + new Field(MetaType.Float, "TunnelSpacing")), + "LaserSight"), + new Field(new MetaStruct("ONWCAmmoMeter", + new Field(MetaType.Pointer(TemplateTag.TXMP), "Icon"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Empty"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Fill")), + "AmmoMeter"), + new Field(MetaType.Pointer(TemplateTag.M3GM), "Geometry"), + new Field(MetaType.String32, "Name"), + new Field(MetaType.Float, "MouseSensitivity"), + new Field(new MetaStruct("ONWCRecoil", + new Field(MetaType.Float, "Base"), + new Field(MetaType.Float, "Max"), + new Field(MetaType.Float, "Factor"), + new Field(MetaType.Float, "ReturnSpeed"), + new Field(MetaType.Float, "FiringReturnSpeed")), + "Recoil"), + new Field(MetaType.Padding(36)), + new Field(MetaType.Padding(2)), + new Field(MetaType.Enum(), "RecoilAnimationType"), + new Field(MetaType.Enum(), "ReloadAnimationType"), + new Field(MetaType.Int16, "PauseAfterReload"), + new Field(MetaType.Int16, "MaxShots"), + new Field(MetaType.Int16, "ParticleCount"), + new Field(MetaType.Int16, "FiringModeCount"), + new Field(MetaType.Int16, "PauseBeforeReload"), + new Field(MetaType.Int16, "ReleaseDelay"), + new Field(MetaType.Padding(2)), + new Field(MetaType.Enum(), "Flags"), + + new Field(MetaType.Array(2, aiFiringMode), "FiringModes"), + + new Field(MetaType.Array(16, new MetaStruct("ONWCParticle", + new Field(MetaType.Matrix4x3, "Transform"), + new Field(MetaType.String16, "ParticleClass"), + new Field(MetaType.Padding(4)), + new Field(MetaType.Int16, "UsedAmmo"), + new Field(MetaType.Int16, "ShotDelay"), + new Field(MetaType.Int16, "RoughJusticeShotDelay"), + new Field(MetaType.Int16, "ActiveFrames"), + new Field(MetaType.Int16, "TriggeredBy"), + new Field(MetaType.Int16, "DelayBeforeFiring") + )), "Particles"), + + new Field(MetaType.String32, "EmptyWeaponSound"), + new Field(MetaType.Padding(4)), + new Field(MetaType.Pointer(TemplateTag.TXMP), "Glow"), + new Field(MetaType.Pointer(TemplateTag.TXMP), "GlowAmmo"), + new Field(MetaType.Vector2, "GlowTextureScale"), + new Field(MetaType.Vector3, "PickupHandleOffset"), + new Field(MetaType.Float, "HoveringHeight") + ); + + public enum TXMPFormat : uint + { + BGRA4444 = 0, + BGR555 = 1, + BGRA5551 = 2, + RGBA = 7, + BGR = 8, + DXT1 = 9 + } + + [Flags] + public enum TXMPFlags : uint + { + None = 0x0000, + HasMipMaps = 0x0001, + DisableUWrap = 0x0004, + DisableVWrap = 0x0008, + Unknown0010 = 0x0010, + AnimBackToBack = 0x0040, + AnimRandom = 0x0080, + AnimUseLocalTime = 0x0100, + HasEnvMap = 0x0200, + AdditiveBlend = 0x0400, + SwapBytes = 0x1000, + AnimIgnoreGlobalTime = 0x4000, + ShieldEffect = 0x8000, + InvisibilityEffect = 0x10000, + DaodanEffect = 0x20000, + } + + // + // Obsolete instances + // + + // + // AI script trigger array template + // + + private static readonly MetaStruct aitr = new MetaStruct("AITRInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(new MetaStruct("AITRElement", + new Field(MetaType.Int16, ""), + new Field(MetaType.Int16, ""), + new Field(MetaType.Int16, ""), + new Field(MetaType.Int16, ""), + new Field(MetaType.Int16, ""), + new Field(MetaType.Int16, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.String64, "") + )), "Elements") + ); + + // + // Gunk Quad Debug Array template + // + + private static readonly MetaStruct agdb = new MetaStruct("AGDBInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.VarArray(new MetaStruct("AGDBElement", + new BinaryPartField(MetaType.RawOffset, "ObjectNameDataOffset"), + new BinaryPartField(MetaType.RawOffset, "FileNameDataOffset") + )), "Elements") + ); + + // + // Door Frame Array template + // + + private static readonly MetaStruct akda = new MetaStruct("AKDAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.Padding(4)) + //new Field(MetaType.LongVarArray(new MetaStruct("AKDADoorFrame", + // new Field(MetaType.Int32, "QuadId"), + // new Field(MetaType.BoundingBox, "BoundingBox"), + // new Field(MetaType.Vector3, "Center"), + // new Field(MetaType.Vector3, "Size") + //)), "DoorFrames") + ); + + // + // Door class array template + // + + private static readonly MetaStruct obdc = new MetaStruct("OBDCInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(new MetaStruct("OBDCElement", + new Field(MetaType.Int16, ""), + new Field(MetaType.Int16, ""), + new Field(MetaType.Pointer(TemplateTag.OBAN), "Animation"), + new Field(MetaType.Padding(4)), + new Field(MetaType.Int32, ""), + new Field(MetaType.Padding(8)) + )), "Elements") + ); + + // + // Imported Flag Node Array template + // + + private static readonly MetaStruct onfa = new MetaStruct("ONFAInstance", + new Field(MetaType.Padding(20)), + new Field(MetaType.Int16, "UsedElements"), + new Field(MetaType.ShortVarArray(new MetaStruct("ONFAElement", + new Field(MetaType.Matrix4x3, "Transform"), + new Field(MetaType.Vector3, "Position"), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int16, "FlagId"), + new Field(MetaType.Byte, ""), + new Field(MetaType.Byte, "") + )), "Elements") + ); + + // + // Imported Marker Node Array template + // + + private static readonly MetaStruct onma = new MetaStruct("ONMAInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(new MetaStruct("ONMAElement", + new Field(MetaType.String64, "Name"), + new Field(MetaType.Vector3, "Position"), + new Field(MetaType.Vector3, "Direction") + )), "Markers") + ); + + // + // Imported Spawn Array template + // + + private static readonly MetaStruct onsa = new MetaStruct("ONSAInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(MetaType.Int16), "Elements") + ); + + // + // Trigger Array template + // + + private static readonly MetaStruct onta = new MetaStruct("ONTAInstance", + new Field(MetaType.Padding(16)), + new Field(MetaType.Int32, ""), + new Field(MetaType.VarArray(new MetaStruct( + new Field(MetaType.Array(8, new MetaStruct( + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, "") + )), ""), + new Field(MetaType.Array(6, new MetaStruct( + new Field(MetaType.Array(4, MetaType.Int32), "") + )), ""), + new Field(MetaType.Array(6, new MetaStruct( + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, "") + )), ""), + new Field(MetaType.Array(6, new MetaStruct( + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, "") + )), ""), + new Field(MetaType.Array(6, MetaType.Int16), ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, ""), + new Field(MetaType.Int32, "") + )), "") + ); + + // + // String Array template + // + + private static readonly MetaStruct stna = new MetaStruct("StNAInstance", + new Field(MetaType.Padding(22)), + new Field(MetaType.ShortVarArray(MetaType.Pointer(TemplateTag.TStr)), "Names") + ); + + // + // String template + // + + private static readonly MetaStruct tstr = new MetaStruct("TStrInstance", + new Field(MetaType.String128, "Text") + ); + + protected virtual void InitializeTemplates(IList