public abstract class GeometryTextBase : DeepTextBase
{
    // Field prevent re-allocations during mesh generation.
    CircularList<Point> list = new CircularList<Point>();

    protected override void Triangulate(
        DependencyPropertyChangedEventArgs args, 
        Point3DCollection vertices, Vector3DCollection normals, 
        Int32Collection indices, PointCollection textures)
    {
        // Clear all four collections.
        vertices.Clear();
        normals.Clear();
        indices.Clear();
        textures.Clear();

        // Convert TextGeometry to series of closed polylines.
        PathGeometry path = 
            TextGeometry.GetFlattenedPathGeometry(0.001, 
            ToleranceType.Relative);

        foreach (PathFigure fig in path.Figures)
        {
            list.Clear();
            list.Add(fig.StartPoint);

            foreach (PathSegment seg in fig.Segments)
            {
                if (seg is LineSegment)
                {
                    LineSegment lineseg = seg as LineSegment;
                    list.Add(lineseg.Point);
                }
                else if (seg is PolyLineSegment)
                {
                    PolyLineSegment polyline = seg as PolyLineSegment;

                    for (int i = 0; i < polyline.Points.Count; i++)
                        list.Add(polyline.Points[i]);
                }
            }

            // Figure is complete. Post-processing follows.
            if (list.Count > 0)
            {
                // Remove last point if it's the same as the first.
                if (list[0] == list[list.Count - 1])
                    list.RemoveAt(list.Count - 1);

                // Convert points to Y increasing up.
                for (int i = 0; i < list.Count; i++)
                {
                    Point pt = list[i];
                    pt.Y = 2 * Origin.Y - pt.Y;
                    list[i] = pt;
                }

                // For each figure, process the points.
                ProcessFigure(list, vertices, normals, 
                    indices, textures);
            }
        }
    }

    // Abstract method to convert figure to mesh geometry.
    protected abstract void ProcessFigure(CircularList<Point> list,
        Point3DCollection vertices, Vector3DCollection normals,
        Int32Collection indices, PointCollection textures);
}

public class RibbonText : GeometryTextBase
{
    protected override void ProcessFigure(CircularList<Point> list,
        Point3DCollection vertices, Vector3DCollection normals,
        Int32Collection indices, PointCollection textures)
    {
        int offset = vertices.Count;

        for (int i = 0; i <= list.Count; i++)
        {
            Point pt = list[i];

            // Set vertices.
            vertices.Add(new Point3D(pt.X, pt.Y, 0));
            vertices.Add(new Point3D(pt.X, pt.Y, -Depth));

            // Set texture coordinates.
            textures.Add(new Point((double)i / list.Count, 0));
            textures.Add(new Point((double)i / list.Count, 1));

            // Set triangle indices.
            if (i < list.Count)
            {
                indices.Add(offset + i * 2 + 0);
                indices.Add(offset + i * 2 + 2);
                indices.Add(offset + i * 2 + 1);
                    
                indices.Add(offset + i * 2 + 1);
                indices.Add(offset + i * 2 + 2);
                indices.Add(offset + i * 2 + 3);
            }
        }
    }
}

<!-- RibbonTextDemo.xaml by Charles Petzold, June 2007 -->
<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:src="clr-namespace:Petzold.Text3D;assembly=Petzold.Text3D"
      WindowTitle="RibbonText Demo"
      Title="RibbonText Demo">

    <Viewport3D>
        <src:RibbonText Text="Ribbon" 
                FontFamily="Times New Roman" Depth="2">
            <src:RibbonText.Material>
                <DiffuseMaterial Brush="Cyan" />
            </src:RibbonText.Material>

            <src:RibbonText.BackMaterial>
                <DiffuseMaterial Brush="Pink" />
            </src:RibbonText.BackMaterial>
        </src:RibbonText>

        <!-- Lights. -->
        <ModelVisual3D>
            <ModelVisual3D.Content>
                <Model3DGroup>
                    <AmbientLight Color="#404040" />
                    <DirectionalLight Color="#C0C0C0" 
                        Direction="2 -3 -1" />
                </Model3DGroup>
            </ModelVisual3D.Content>
        </ModelVisual3D>

        <!-- Camera. -->
        <Viewport3D.Camera>
            <PerspectiveCamera Position="-3 0 8" UpDirection="0 1 0"
                               LookDirection="1 0 -2" FieldOfView="45" />
        </Viewport3D.Camera>
    </Viewport3D>
</Page> 

public class SolidText : DeepTextBase
{
    public SolidText()
    {
        // Create RibbonText and two PlanarText children.
        RibbonText ribbon = new RibbonText();
        ribbon.Depth = Depth;
        Children.Add(ribbon);

        PlanarText planar = new PlanarText();
        Children.Add(planar);

        planar = new PlanarText();
        planar.Z = -Depth;
        Children.Add(planar);
    }

    // SideMaterial dependency property and property.
    public static readonly DependencyProperty SideMaterialProperty =
        DependencyProperty.Register("SideMaterial",
            typeof(Material), typeof(SolidText),
            new PropertyMetadata(SideMaterialChanged));

    public Material SideMaterial
    {
        set { SetValue(SideMaterialProperty, value); }
        get { return (Material)GetValue(SideMaterialProperty); }
    }

    // SideMaterialChanged handlers.
    static void SideMaterialChanged(DependencyObject obj,
        DependencyPropertyChangedEventArgs args)
    {
        ((SolidText)obj).SideMaterialChanged(args);
    }

    void SideMaterialChanged(DependencyPropertyChangedEventArgs args)
    {
        // Transfer SideMaterial to RibbonText.
        Text3DBase txtbase = Children[0] as Text3DBase;
        txtbase.Material = args.NewValue as Material;
        txtbase.BackMaterial = args.NewValue as Material;
    }

    // MaterialChanged override.
    protected override void MaterialPropertyChanged(
        DependencyPropertyChangedEventArgs args)
    {
        // Transfer Material and BackMaterial properties to PlanarText.
        if (args.Property == MaterialProperty)
            ((PlanarText )Children[1] ).Material = 
                                    args.NewValue as Material;

        else if (args.Property == BackMaterialProperty)
            ((PlanarText)Children[2]).BackMaterial = 
                                   args.NewValue as Material;
    }

    // TextPropertyChanged override.
    protected override void TextPropertyChanged(
        DependencyPropertyChangedEventArgs args)
    {
        base.TextPropertyChanged(args);

        // Transfer text-related property to all three children.
        for (int i = 0; i < 3; i++)
        {
            Text3DBase txtbase = Children[i] as Text3DBase;
            txtbase.SetValue(args.Property, args.NewValue);
        }
    }

    // PropertyChanged override.
    protected override void PropertyChanged(
        DependencyPropertyChangedEventArgs args)
    {
        if (args.Property == DepthProperty)
        {
            // Set Depth property to RibbonText and PlanarText children.
            double depth = (double)args.NewValue;
            ((DeepTextBase )Children[0]).Depth = depth;
            ((PlanarText)Children[2]).Z = -depth;
        }

        base.PropertyChanged(args);
    }

    // Move on, move on. Nothing to see here. 
    protected override void Triangulate(
        DependencyPropertyChangedEventArgs args, 
        Point3DCollection vertices, Vector3DCollection normals, 
        Int32Collection indices, PointCollection textures)
    {}
}