anx.framework/ANX.Framework.Content.Pipeline/Graphics/MeshHelper.cs

#region Using Statements
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

#endregion

// This file is part of the ANX.Framework created by the
// "ANX.Framework developer group" and released under the Ms-PL license.
// For details see: http://anxframework.codeplex.com/license

namespace ANX.Framework.Content.Pipeline.Graphics
{
    public static class MeshHelper
    {
        private static bool HasCompleteNormals(MeshContent mesh)
        {
            foreach (var geometry in mesh.Geometry)
            {
                if (!geometry.Vertices.Channels.Contains(VertexChannelNames.Normal()))
                {
                    return false;
                }
            }
            return true;
        }

        public static void CalculateNormals(MeshContent mesh, bool overwriteExistingNormals)
        {
            if (mesh == null)
                throw new ArgumentNullException("mesh");

            if (!overwriteExistingNormals && HasCompleteNormals(mesh))
            {
                return;
            }

            foreach (GeometryContent geometry in mesh.Geometry)
            {
                VertexChannelCollection channels = geometry.Vertices.Channels;
                if (overwriteExistingNormals)
                {
                    channels.Remove(VertexChannelNames.Normal());
                }
                else if (channels.Contains(VertexChannelNames.Normal()))
                {
                    continue;
                }

                Vector3[] normals = new Vector3[mesh.Positions.Count];
                IndirectPositionCollection positions = geometry.Vertices.Positions;
                VertexChannel<int> positionIndices = geometry.Vertices.PositionIndices;
                for (int i = 0; i < positionIndices.Count; i += 3)
                {
                    Vector3 vector = positions[positionIndices[i + 1]];
                    //Calculate the normale for the given Vector.
                    Vector3 normalVector = Vector3.SafeNormalize(Vector3.Cross(positions[positionIndices[i + 2]] - vector, vector - positions[positionIndices[i]]));
                    for (int j = 0; j < 3; j++)
                    {
                        normals[positionIndices[geometry.Indices[i + j]]] = normalVector;
                    }
                }

                VertexChannel<Vector3> vertexChannel = channels.Add<Vector3>(VertexChannelNames.Normal(), null);
                for (int i = 0; i < vertexChannel.Count; i++)
                {
                    vertexChannel[i] = normals[positionIndices[i]];
                }
            }
        }

        //description from msdn.
        /// <summary>
        /// Compute tangent frames for the given mesh. 
        /// </summary>
        /// <remarks>
        /// This method computes and adds tangent and binormal vertex channels to the given mesh.
        /// 
        /// An InvalidContentException is thrown if:
        /// <list type="bullet">
        ///     <item>The mesh does not contain a normal channel (stored in Normal).</item>
        ///     <item>The data specified in the normal channel is not a Vector3 type.</item>
        ///     <item>The vertex channel of the mesh does not have the name specified by textureCoordinateChannelName.</item>
        ///     <item>The data specified in the texture coordinate channel is not a Vector2 type.</item>
        ///     <item>The channel specified by tangentChannelName already exists.</item>
        ///     <item>The channel specified by binormalChannelName already exists.</item>
        /// </list>
        /// </remarks>
        /// <param name="mesh">The target mesh used to create the tangent frame. All geometries in this mesh must have normal vertex channels stored in Normal, and must contain Vector3 data.</param>
        /// <param name="textureCoordinateChannelName">The texture coordinate channel used for computing the tangent frame. This channel most contain Vector2 data.</param>
        /// <param name="tangentChannelName">Target channel name used to store calculated tangents. A tangent channel is not generated if null or an empty string is specified.</param>
        /// <param name="binormalChannelName">Target channel name used to store calculated binormals. A tangent channel is not generated if null or an empty string is specified.</param>
        /// <exception cref="System.ArgumentNullException"></exception>
        /// <exception cref="ANX.Framework.Content.Pipeline.InvalidContentException"></exception>
        public static void CalculateTangentFrames(MeshContent mesh, string textureCoordinateChannelName, string tangentChannelName, string binormalChannelName)
        {
            if (mesh == null)
                throw new ArgumentNullException("mesh");
            
            if (string.IsNullOrEmpty(textureCoordinateChannelName))
                throw new ArgumentNullException("textureCoordinateChannelName");
            
            //Check first for all the cases that we throw an InvalidContentException.
            foreach (var geometry in mesh.Geometry)
            {
                VertexChannelCollection channels = geometry.Vertices.Channels;
                if (!channels.Contains(VertexChannelNames.Normal()))
                    throw new InvalidContentException(string.Format("Does not contain a channel for {0}.", mesh.Name, VertexChannelNames.Normal()), mesh.Identity);

                if (channels[VertexChannelNames.Normal()].ElementType != typeof(Vector3))
                    throw new InvalidContentException(string.Format("ElementType of channel \"{0}\" is not {1}, found instead {2}.", VertexChannelNames.Normal(), typeof(Vector3).Name, channels[VertexChannelNames.Normal()].ElementType), mesh.Identity);

                if (!channels.Contains(textureCoordinateChannelName))
                    throw new InvalidContentException(string.Format("Does not contain a channel with the name \"{0}\".", textureCoordinateChannelName), mesh.Identity);

                if (channels[textureCoordinateChannelName].ElementType != typeof(Vector2))
                    throw new InvalidContentException(string.Format("ElementType of channel \"{0}\" is not {1}, found instead {2}.", textureCoordinateChannelName, typeof(Vector2).Name, channels[textureCoordinateChannelName].ElementType), mesh.Identity);
                
                if (!string.IsNullOrEmpty(tangentChannelName) && channels.Contains(tangentChannelName))
                    throw new InvalidContentException(string.Format("Wanted to create a new channel for \"{0}\", but it already exists.", tangentChannelName), mesh.Identity);

                if (!string.IsNullOrEmpty(binormalChannelName) && channels.Contains(binormalChannelName))
                    throw new InvalidContentException(string.Format("Wanted to create a new channel for \"{0}\", but it already exists.", binormalChannelName), mesh.Identity);
            }

            throw new NotImplementedException();
        }

        public static BoneContent FindSkeleton(NodeContent node)
        {
            if (node == null)
                throw new ArgumentNullException("node");
            
            while (node != null)
            {
                if (node is BoneContent)
                {
                    BoneContent boneContent = (BoneContent)node;
                    while (boneContent.Parent is BoneContent)
                    {
                        boneContent = (BoneContent)boneContent.Parent;
                    }
                    return boneContent;
                }

                node = node.Parent;
            }
            return null;
        }

        public static IList<BoneContent> FlattenSkeleton(BoneContent skeleton)
        {
            if (skeleton == null)
                throw new ArgumentNullException("skeleton");

            Dictionary<BoneContent, bool> list = new Dictionary<BoneContent, bool>();
            MeshHelper.FlattenSkeleton(skeleton, list);
            return list.Keys.ToList();
        }

        private static void FlattenSkeleton(BoneContent skeleton, Dictionary<BoneContent, bool> list)
        {
            if (list.ContainsKey(skeleton))
            {
                throw new ArgumentException("The skeleton contains duplicate entries: {0}", skeleton.Name);
            }

            list.Add(skeleton, false);
            foreach (var child in skeleton.Children)
            {
                if (child is BoneContent)
                {
                    FlattenSkeleton((BoneContent)child, list);
                }
            }
        }

        public static void MergeDuplicatePositions(MeshContent mesh, float tolerance)
        {
            if (mesh == null)
                throw new ArgumentNullException("mesh");

            //TODO: test
            float toleranceSquared = tolerance * tolerance;

            var positions = mesh.Positions;
            for (int i = 0; i < positions.Count; i++)
            {
                for (int j = positions.Count - 1; j > i; j--)
                {
                    if (Vector3.DistanceSquared(positions[i], positions[j]) < toleranceSquared)
                    {
                        //Remove duplicate position.
                        positions.RemoveAt(j);

                        foreach (GeometryContent geometry in mesh.Geometry)
                        {
                            var positionIndices = geometry.Vertices.PositionIndices;
                            for (int k = 0; k < positionIndices.Count; k++)
                            {
                                if (positionIndices[k] == j)
                                {
                                    positionIndices[k] = i;
                                }
                                //reduce the index for all position indexes that references the removed position by 1.
                                else if (positionIndices[k] > j)
                                {
                                    positionIndices[k]--;
                                }
                            }
                        }

                        j++;
                    }
                }
            }
        }

        public static void MergeDuplicateVertices(GeometryContent geometry)
        {
            if (geometry == null)
                throw new ArgumentNullException("geometry");

            List<int> newIndices = new List<int>();
            List<int> newPositionIndices = new List<int>();
            //Maps from the index in newPositionIndices to the index in the old position indices.
            List<int> positionIndexMapping = new List<int>();
            
            //Find positionIndex duplicates
            var positionIndices = geometry.Vertices.PositionIndices;
            for (int i = 0; i < positionIndices.Count; i++)
            {
                int index = newPositionIndices.IndexOf(positionIndices[i]);
                //If the positionIndex is not in the list, add it.
                if (index == -1)
                {
                    index = newPositionIndices.Count;
                    newPositionIndices.Add(positionIndices[i]);
                    positionIndexMapping.Add(i);
                }
                else
                {
                    var originalIndex = positionIndexMapping[index];
                    //check other channels, if any of them has other data, we can't skip that vertex.
                    foreach (var channel in geometry.Vertices.Channels)
                    {
                        var originalVertex = channel[originalIndex];
                        var currentVertex = channel[i];

                        //Only add an positionIndex that was already found if the vertex represented is different in any channel.
                        if (currentVertex != null && (originalVertex == null || !originalVertex.Equals(currentVertex)))
                        {
                            index = newPositionIndices.Count;
                            newPositionIndices.Add(positionIndices[i]);
                            positionIndexMapping.Add(i);
                            break;
                        }
                    }
                }

                newIndices.Add(index);
            }

            if (newPositionIndices.Count != positionIndices.Count)
            {
                geometry.Indices.Clear();
                geometry.Indices.AddRange(newIndices);

                //Copy the needed data from the vertex channels.
                var channels = geometry.Vertices.Channels;
                List<object>[] vertexChannelsData = new List<object>[channels.Count];
                for (int i = 0; i < channels.Count; i++)
                {
                    List<object> data = new List<object>();
                    vertexChannelsData[i] = data;

                    var channel = channels[i];
                    for (int j = 0; j < newPositionIndices.Count; j++)
                    {
                        data.Add(channel[positionIndexMapping[j]]);
                    }
                }

                //Set new position indices.
                positionIndices.Clear();
                positionIndices.AddRange(newPositionIndices);

                //Set data of the vertex channels.
                for (int i = 0; i < channels.Count; i++)
                {
                    var channel = channels[i];

                    channel.Clear();
                    channel.AddRange(vertexChannelsData[i]);
                }
            }
        }

        public static void MergeDuplicateVertices(MeshContent mesh)
        {
            if (mesh == null)
                throw new ArgumentNullException("mesh");

            foreach (var geometry in mesh.Geometry)
            {
                MergeDuplicateVertices(geometry);
            }
        }

        public static void OptimizeForCache(MeshContent mesh)
        {
            if (mesh == null)
                throw new ArgumentNullException("mesh");


        }

        public static void SwapWindingOrder(MeshContent mesh)
        {
            if (mesh == null)
                throw new ArgumentNullException("mesh");
            
            foreach (var geometry in mesh.Geometry)
            {
                var indices = geometry.Indices;
                if (indices.Count % 3 != 0)
                    throw new ArgumentException(string.Format("Number of indices in geometry \"{0}\" is not a multiple of 3.", geometry.Name));

                for (int i = 0; i < indices.Count; i += 3)
                {
                    //Flip the start and the end index of the triangle.
                    int index = indices[i];

                    indices[i] = indices[i + 2];
                    indices[i + 2] = index;
                }
            }
        }

        /// <summary>
        /// Applies a transformation to the contents of a scene hierarchy. 
        /// </summary>
        /// <remarks>
        /// The resulting world space positions are similar to the results obtained from applying the specified transform to the Transform property of the scene object. 
        /// However, this method performs the transformation by cascading down through the scene hierarchy and modifying the actual underlying vertex positions. 
        /// </remarks>
        /// <param name="scene">Scene hierarchy being transformed.</param>
        /// <param name="transform">Matrix used in the transformation</param>
        public static void TransformScene(NodeContent scene, Matrix transform)
        {
            if (scene is MeshContent)
            {
                var mesh = (MeshContent)scene;
                
                var positions = mesh.Positions;
                for (int i = 0; i < positions.Count; i++)
                {
                    positions[i] = Vector3.Transform(positions[i], transform);
                }
            }

            foreach (var animation in scene.Animations.Values)
            {
                foreach (var channel in animation.Channels.Values)
                {
                    for (int i = 0; i < channel.Count; i++)
                    {
                        channel[i].Transform *= transform;
                    }
                }
            }

            foreach (var child in scene.Children)
            {
                TransformScene(child, transform);
            }
        }
    }
}