void insertTextBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
            BackgroundWorker backgroundWorker = (BackgroundWorker)sender;

            asynchMeshesList.Clear();
            asynchMeshTransforms.Clear();
            asynchPlatingDataList.Clear();

            string currentText = (string)e.Argument;
            TypeFacePrinter printer = new TypeFacePrinter(currentText, new StyledTypeFace(boldTypeFace, 12));
            Vector2 size = printer.GetSize(currentText);
            double centerOffset = -size.x / 2;

            for (int i = 0; i < currentText.Length; i++)
            {
                int newIndex = asynchMeshesList.Count;

                TypeFacePrinter letterPrinter = new TypeFacePrinter(currentText[i].ToString(), new StyledTypeFace(boldTypeFace, 12));
                Mesh textMesh = VertexSourceToMesh.Extrude(letterPrinter, 10 + (i%2));

                if (textMesh.Faces.Count > 0)
                {
                    asynchMeshesList.Add(textMesh);

                    PlatingMeshData newMeshInfo = new PlatingMeshData();

                    newMeshInfo.xSpacing = printer.GetOffsetLeftOfCharacterIndex(i).x + centerOffset;
                    asynchPlatingDataList.Add(newMeshInfo);
                    asynchMeshTransforms.Add(ScaleRotateTranslate.Identity());

                    PlatingHelper.CreateITraceableForMesh(asynchPlatingDataList, asynchMeshesList, newIndex);

                    PlatingHelper.PlaceMeshOnBed(asynchMeshesList, asynchMeshTransforms, newIndex, false);
                }

                backgroundWorker.ReportProgress((i + 1) * 95 / currentText.Length);
            }


            SetWordSpacing(asynchMeshesList, asynchMeshTransforms, asynchPlatingDataList);
            SetWordSize(asynchMeshesList, asynchMeshTransforms);
            SetWordHeight(asynchMeshesList, asynchMeshTransforms);

            if (createUnderline.Checked)
            {
                CreateUnderline(asynchMeshesList, asynchMeshTransforms, asynchPlatingDataList);
            }

            backgroundWorker.ReportProgress(95);
        }
 private void PushMeshDataToAsynchLists(bool copyTraceInfo)
 {
     asynchMeshesList.Clear();
     asynchMeshTransforms.Clear();
     for (int i = 0; i < Meshes.Count; i++)
     {
         Mesh mesh = Meshes[i];
         asynchMeshesList.Add(new Mesh(mesh));
         asynchMeshTransforms.Add(MeshTransforms[i]);
     }
     asynchPlatingDataList.Clear();
     for (int i = 0; i < MeshPlatingData.Count; i++)
     {
         PlatingMeshData meshData = new PlatingMeshData();
         meshData.currentScale = MeshPlatingData[i].currentScale;
         if (copyTraceInfo)
         {
             meshData.traceableData = MeshPlatingData[i].traceableData;
         }
         asynchPlatingDataList.Add(meshData);
     }
 }
        void createDiscreteMeshesBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
            BackgroundWorker backgroundWorker = (BackgroundWorker)sender;

            Mesh[] meshes = CreateDiscreteMeshes.SplitIntoMeshes(SelectedMesh, meshViewerWidget.DisplayVolume, backgroundWorker, 0, 50);

            asynchMeshesList.Clear();
            asynchPlatingDataList.Clear();
            asynchMeshTransforms.Clear();
            for (int i = 0; i < meshes.Length; i++)
            {
                PlatingMeshData newInfo = new PlatingMeshData();
                asynchPlatingDataList.Add(newInfo);
                asynchMeshesList.Add(meshes[i]);
                asynchMeshTransforms.Add(new ScaleRotateTranslate(SelectedMeshTransform.scale, SelectedMeshTransform.rotation, Matrix4X4.Identity));

                Mesh mesh = asynchMeshesList[i];

                // remember where it is now
                AxisAlignedBoundingBox startingBounds = mesh.GetAxisAlignedBoundingBox(asynchMeshTransforms[i].TotalTransform);
                Vector3 startingCenter = (startingBounds.maxXYZ + startingBounds.minXYZ) / 2;

                // move the mesh to be centered on the origin
                AxisAlignedBoundingBox meshBounds = mesh.GetAxisAlignedBoundingBox();
                Vector3 meshCenter = (meshBounds.maxXYZ + meshBounds.minXYZ) / 2;
                mesh.Translate(-meshCenter);

                // set the transform to position it where it was
                ScaleRotateTranslate meshTransform = asynchMeshTransforms[i];
                meshTransform.translation = Matrix4X4.CreateTranslation(startingCenter);
                asynchMeshTransforms[i] = meshTransform;
                PlatingHelper.PlaceMeshOnBed(asynchMeshesList, asynchMeshTransforms, i, false);

                // and create selection info
                PlatingHelper.CreateITraceableForMesh(asynchPlatingDataList, asynchMeshesList, i);
                if (meshes.Length > 1)
                {
                    backgroundWorker.ReportProgress(50 + i * 50 / (meshes.Length - 1));
                }
            }
        }