Are there mesh building helper classes in WPF or .NET 4.0?

The mechanisms for building a mesh in WPF are quite low-level. For exam开发者_运维问答ple you have to supply the vertexes and the indexes. Are there helpers in the WPF or anywhere in the .NET 4.0 framework I can use? Or do I have to resort to third party libraries?

---

Here's an older chunk of XNA 3.1 code I wrote to build a Sphere. I apply a transformation matrix in my rendering loop that allows me to stretch and orient it. Computing the vertices is fairly straightforward... computing the indices are what I find more difficult. This should hopefully give you an idea, though. The other primitives (e.g. cone, cylinder, cube...) are much simpler to compute.

The m_iSegments paremeter just allows me to define how many slices I want to divide the sphere into... the more segments, the more vertices, the smoother the sphere.

The m_Appearance parameter is my wrapper for the shader.

        /// <summary>
        /// This method constructs ellipsoid vertices, indices, and normals.
        /// Equations are performed using the parameterized equations:
        /// 
        /// x = a cos(B)cos(L)
        /// y = b cos(B)sin(L)
        /// z = c sin(B)
        /// 
        /// Where:
        /// 
        /// B = latitude and,
        /// L = longitude
        /// 
        /// </summary>
        /// <seealso cref="http://en.wikipedia.org/wiki/Ellipsoid">Wikipedia - Ellipsoid</seealso>
        public override void BuildVertices()
        {
            #region Declarations

            int iIndex = 0;                                     // Stores the index of the vertex array.
            int iBeta = 0;                                      // Stores the beta increment.
            int iLambda = 0;                                    // Stores the lambda increment.
            float Beta = 0.0f;                                  // Beta0 - Stores the latitude.
            float Lambda = 0.0f;                                // Lambda0 - Stores the longitude.
            float BetaStep = MathHelper.Pi / m_iSegments;       // Latitude Segements, in degrees.
            float LambdaStep = MathHelper.TwoPi / m_iSegments;  // Longitude Segments, in degrees.
            Vector3 vectPos = Vector3.Zero;                     // Vertex Position Vector
            Vector3 vectNor = Vector3.Zero;                     // Vertex Normal Vector
            Vector2 vectTex = Vector2.Zero;                     // Vertex Texture Coordinate

            #endregion

            #region Build the vertices.

            int[] iIndices = new int[6 * m_iSegments * m_iSegments];
            Vector3[] vVertices = new Vector3[(m_iSegments + 1) * (m_iSegments + 1)];
            Vector2[] vTexCrds  = new Vector2[vVertices.Length];

            iIndex = 0;

            for (iBeta = 0; iBeta <= m_iSegments; iBeta++)
            {
                // Compute the latitude.
                Beta = MathHelper.Clamp((-MathHelper.PiOver2) + (iBeta * BetaStep), -MathHelper.PiOver2, MathHelper.PiOver2);

                for (iLambda = 0; iLambda <= m_iSegments; iLambda++)
                {
                    // Compute the current longitude.
                    Lambda = MathHelper.Clamp((-MathHelper.Pi) + (iLambda * LambdaStep), -MathHelper.Pi, MathHelper.Pi);

                    // Compute the current vertex.
                    vVertices[iIndex] = new Vector3((float)(Math.Cos(Beta) * Math.Sin(Lambda)),
                                                    (float)(Math.Sin(Beta)),
                                                    (float)(Math.Cos(Beta) * Math.Cos(Lambda)));

                    // Compute the triangle indices.
                    if (iBeta < m_iSegments &&
                        iLambda < m_iSegments)
                    {
                        iIndices[iIndex + (iIndex * 5) - (iBeta * 6) + 0] = iIndex;
                        iIndices[iIndex + (iIndex * 5) - (iBeta * 6) + 1] = iIndex + m_iSegments + 1;
                        iIndices[iIndex + (iIndex * 5) - (iBeta * 6) + 2] = iIndex + m_iSegments + 2;
                        iIndices[iIndex + (iIndex * 5) - (iBeta * 6) + 3] = iIndex;
                        iIndices[iIndex + (iIndex * 5) - (iBeta * 6) + 4] = iIndex + m_iSegments + 2;
                        iIndices[iIndex + (iIndex * 5) - (iBeta * 6) + 5] = iIndex + 1;
                    }

                    // Compute the texture coordinates.
                    vTexCrds[iIndex] = new Vector2((float)iLambda / (float)m_iSegments, 1.0f - (float)iBeta / (float)m_iSegments);

                    iIndex++;
                }

            }

            # endregion

            #region Build the normals.

            Vector3[] vNormals = new Vector3[vVertices.Length];
            for (iIndex = 0; iIndex < vVertices.Length; iIndex++)
            {
                vNormals[iIndex] = vVertices[iIndex] - this.AbsolutePosition;
                vNormals[iIndex].Normalize();
            }

            #endregion

            #region Build the buffers.

            VertexPositionNormalTexture[] vertices = new VertexPositionNormalTexture[vVertices.Length];
            for (iIndex = 0; iIndex < vVertices.Length; iIndex++)
                vertices[iIndex] = new VertexPositionNormalTexture(vVertices[iIndex], vNormals[iIndex], vTexCrds[iIndex]);
            m_pAppearance.SetBuffers(vertices, iIndices);

            #endregion
       }