OOGL

public struct Triangle
    {
        private ushort[] Indicies; // pointer to 3 vertices
 
        public ushort First { get { return Indicies[0]; } }
        public ushort Second { get { return Indicies[1]; } }
        public ushort Third { get { return Indicies[2]; } }
 
        public bool HasBeenProcessed; // (vertex cache opt) true if the triangle has been added to the list already.
 
        public Triangle( ushort first, ushort second, ushort third )
        {
            if ( first == second || first == third || second == third )
                throw new ApplicationException( "Degenerate Triangle found. A: " + first + " B: " + second + " C: " + third );
 
            Indicies = new ushort[3];
            Indicies[0] = first;
            Indicies[1] = second;
            Indicies[2] = third;
 
            HasBeenProcessed = false;
        }
    }
 
 public struct Vertex
    {
        public Vector3 Position; 
        public Vector3 Normal; 
        public Vector2 UV; 
        public Bytes4 BoneIndex; // index of joint or 255, if 255 then that weight is ignored
        public Bytes4 BoneWeights; // vertex weight ranging from 0 - 100, last weight is computed by 1.0 - sum(all weights)
 
        public int CacheTimestamp; // (vertex cache opt) used to track how long ago the Vertex has been processed
        public ArrayList ReferencedTriangles; // (vertex cache opt) contains a list of all triangles using this vertex
        public byte TriangleCount; // (vertex cache opt) number of triangles left in ReferencedTriangles
 
        public Vertex( Vector3 position, Vector2 uv, Vector3 normal, byte[] boneids, byte[] weight )
        {
// truncated ....
            CacheTimestamp = -1;
            ReferencedTriangles = null;
            TriangleCount = 0;
        }
    }

public static void Optimize( ref Vertex[] VertexList, ref Triangle[] TriList, int CacheSize )
        {
            // Iterate through all Vertices, build a list of triangles using it
            for ( int currentVertex = 0; currentVertex < VertexList.Length; currentVertex++ )
            {
                VertexList[currentVertex].ReferencedTriangles = new ArrayList( );
                // iterate through the mesh and check if any triangle uses the currently examined vertex
                for ( int currentTriangle = 0; currentTriangle < TriList.Length; currentTriangle++ )
                {
                    if ( TriList[currentTriangle].First == currentVertex ||
                         TriList[currentTriangle].Second == currentVertex ||
                         TriList[currentTriangle].Third == currentVertex )
                    {  // if any of the indices is the currently examined vertex, remember this triangle 
                        VertexList[currentVertex].ReferencedTriangles.Add( currentTriangle );
                        VertexList[currentVertex].TriangleCount++;
                    }
                }
            }
 
            // implementation of the Tipsy algorythm
            Stack DeadEndStack = new Stack( ); // Dead-end vertex stack
            ArrayList NextCandidates = new ArrayList( ); // 1-ring of next candidates
            Queue Output = new Queue( ); // Empty output buffer
            int currentIndex = 0; // Arbitrary starting vertex
            int Stamp = CacheSize + 1; // time stamp
            int Cursor = 1; // cursor
            while ( currentIndex >= 0 ) // For all valid fanning vertices
            {
                NextCandidates.Clear( );
                foreach ( int tri in VertexList[currentIndex].ReferencedTriangles )
                {
                    if ( !TriList[tri].HasBeenProcessed ) // make sure no triangle is queued more than once
                        foreach ( ushort Index in TriList[tri].Indicies )
                        {
                            Output.Enqueue( Index );// Output vertex 
                            DeadEndStack.Push( Index ); // Add to dead-end stack
                            NextCandidates.Add( Index ); // Register as candidate
                            VertexList[Index].TriangleCount--; // Decrease live triangle count
                            if ( Stamp - VertexList[Index].CacheTimestamp > CacheSize ) // If not in cache
                            {
                                VertexList[Index].CacheTimestamp = Stamp; // Set time stamp
                                Stamp++; // Increment time stamp
                            }
                        }
                    TriList[tri].HasBeenProcessed = true;// Flag triangle as emitted
 
                }
                //Select next fanning vertex
                int m = 0;
                ;
                int n = -1;
                int p = -1; // Best candidate and priority
                foreach ( ushort Index in NextCandidates )
                {
                    if ( VertexList[Index].TriangleCount > 0 ) // Must have live triangles
                    {
                        p = 0; // Initial priority
                        if ( Stamp - VertexList[Index].CacheTimestamp + 2 * VertexList[Index].TriangleCount <= CacheSize ) // In cache even after fanning?
                        {
                            p = Stamp - VertexList[Index].CacheTimestamp; // Priority is position in cache
                        }
                        if ( p > m ) // Keep best candidate
                        {
                            m = p;
                            n = Index;
                        }
                    }
                }
                if ( n == -1 ) // Reached a dead-end?
                {
                    n = SkipDeadEnd( ref VertexList, DeadEndStack, Cursor ); // Get non-local vertex
                }
                currentIndex = n;
            }
 
            Debug.Assert( Output.Count % 3 == 0 ); // must be a multiple of 3, a triangle has 3 verts
            Triangle[] temptrilist = new Triangle[(int) ( Output.Count / 3 )];
            for ( ushort i = 0; i < temptrilist.Length; i++ )
            {
                ushort first = (ushort) Output.Dequeue( );
                ushort second = (ushort) Output.Dequeue( );
                ushort third = (ushort) Output.Dequeue( );
                temptrilist[i] = new Triangle( first, second, third );
            }
 
            TriList = temptrilist;
 
            // check if the optimizer "forgot" any triangles and clear the reference lists for each vertex
            for ( ushort i = 0; i < VertexList.Length; i++ )
                if ( VertexList[i].TriangleCount != 0 )
                {
                    if ( Verbose != eVerbose.Silence )
                        Log( "Warning: Not all triangles referencing Vertex (" + i + ") have been processed." );
                    VertexList[i].ReferencedTriangles.Clear( );
                }
 
            // clean up
            Output.Clear( );
            DeadEndStack.Clear( );
            NextCandidates.Clear( );
        }
 
        private static int SkipDeadEnd( ref Vertex[] VertexList, Stack MyStack, int Index )
        {
            while ( MyStack.Count > 0 ) // Next in dead-end stack
            {
                ushort d = (ushort) MyStack.Pop( );
                if ( VertexList[d].TriangleCount > 0 ) // Check for live triangles
                    return d;
            }
            while ( Index < VertexList.Length ) // Next in input order
            {
                Index++; // Cursor sweeps list only once
                if ( Index >= VertexList.Length )
                    return -1;
                if ( VertexList[Index].TriangleCount > 0 ) // Check for live triangles
                    return Index;
            }
            return -1; // We are done!
        }
    }

int bone = int(boneAttribute)

mat3 normalAnimation = mat3(vertexAnimation);