Reign.Video.Abstraction.Mesh.initData C# (CSharp) Method

        private static void initData(SoftwareMesh softwareMesh, bool loadColors, bool loadUVs, bool loadNormals, out List<BufferLayoutElement> elements, out float[] vertices, out int[] indices)
        {
            // get position float size
            int posFloatCount = 0;
            var posElementType = BufferLayoutElementTypes.Vector3;
            switch (softwareMesh.Dimensions)
            {
                case 2:
                    posElementType = BufferLayoutElementTypes.Vector2;
                    posFloatCount = 2;
                    break;

                case 3:
                    posElementType = BufferLayoutElementTypes.Vector3;
                    posFloatCount = 3;
                    break;
            }

            // get vertex float size and create layout
            elements = new List<BufferLayoutElement>();
            int vertFloatCount = 0, posCount = 0, colorCount = 0, normalCount = 0, uvCount = 0;
            foreach (var key in softwareMesh.VertexComponentKeys)
            {
                switch (key.Key)
                {
                    case VertexComponentKeyTypes.Positions:
                        elements.Add(new BufferLayoutElement(posElementType, BufferLayoutElementUsages.Position, 0, posCount, vertFloatCount));
                        vertFloatCount += posFloatCount;
                        ++posCount;
                        break;
                }
            }

            foreach (var key in softwareMesh.TriangleComponentKeys)
            {
                switch (key.Key)
                {
                    case TriangleComponentKeyTypes.ColorComponents:
                        if (loadColors)
                        {
                            elements.Add(new BufferLayoutElement(BufferLayoutElementTypes.Vector4, BufferLayoutElementUsages.Color, 0, colorCount, vertFloatCount));
                            vertFloatCount += 4;
                            ++colorCount;
                        }
                        break;

                    case TriangleComponentKeyTypes.NormalComponents:
                        if (loadNormals)
                        {
                            elements.Add(new BufferLayoutElement(BufferLayoutElementTypes.Vector3, BufferLayoutElementUsages.Normal, 0, normalCount, vertFloatCount));
                            vertFloatCount += 3;
                            ++normalCount;
                        }
                        break;

                    case TriangleComponentKeyTypes.UVComponents:
                        if (loadUVs)
                        {
                            elements.Add(new BufferLayoutElement(BufferLayoutElementTypes.Vector2, BufferLayoutElementUsages.UV, 0, uvCount, vertFloatCount));
                            vertFloatCount += 2;
                            ++uvCount;
                        }
                        break;
                }
            }

            // create vertex buffer
            var meshProcessor = new HardwareMeshProcessor(softwareMesh, loadColors, loadUVs, loadNormals);
            vertices = new float[meshProcessor.Verticies.Count * vertFloatCount];
            int vi = 0;
            foreach (var vertex in meshProcessor.Verticies)
            {
                int posIndex = 0, colorIndex = 0, normIndex = 0, uvIndex = 0;
                foreach (var element in elements)
                {
                    switch (element.Usage)
                    {
                        case BufferLayoutElementUsages.Position:
                            vertices[vi] = vertex.Positions[posIndex].X;
                            vertices[vi+1] = vertex.Positions[posIndex].Y;
                            if (posFloatCount == 3) vertices[vi+2] = vertex.Positions[posIndex].Z;
                            vi += posFloatCount;
                            ++posIndex;
                            break;

                        case BufferLayoutElementUsages.Color:
                            if (loadColors)
                            {
                                vertices[vi] = vertex.Colors[uvIndex].X;
                                vertices[vi+1] = vertex.Colors[uvIndex].Y;
                                vi += 4;
                                ++colorIndex;
                            }
                            break;

                        case BufferLayoutElementUsages.Normal:
                            if (loadNormals)
                            {
                                vertices[vi] = vertex.Normals[normIndex].X;
                                vertices[vi+1] = vertex.Normals[normIndex].Y;
                                vertices[vi+2] = vertex.Normals[normIndex].Z;
                                vi += 3;
                                ++normIndex;
                            }
                            break;

                        case BufferLayoutElementUsages.UV:
                            if (loadUVs)
                            {
                                vertices[vi] = vertex.UVs[uvIndex].X;
                                vertices[vi+1] = vertex.UVs[uvIndex].Y;
                                vi += 2;
                                ++uvIndex;
                            }
                            break;
                    }
                }
            }

            // create index buffer
            indices = new int[meshProcessor.Triangles.Count * 3];
            int ti = 0;
            foreach (var triangle in meshProcessor.Triangles)
            {
                indices[ti] = triangle.Verticies[0].Index;
                indices[ti+1] = triangle.Verticies[1].Index;
                indices[ti+2] = triangle.Verticies[2].Index;
                ti += 3;
            }
        }