/// <summary>
        /// Applies mesh changes back to the pb_Object (if necessary).  Optionally does a
        /// mesh rebuild.
        /// </summary>
        /// <param name="rebuildMesh">Only applies to ProBuilder meshes.</param>
        /// <param name="optimize">Determines if the mesh collisions are rebuilt (if that option is enabled) or if
        /// the mehs is a probuilder object, the mesh is optimized (condensed to share verts, other
        /// otpimziations etc) </param>
        internal void Apply(bool rebuildMesh, bool optimize = false)
        {
            if (m_PolybrushMesh.mode == PolybrushMesh.Mode.AdditionalVertexStream)
            {
                if (PolyEditor.instance.tool == BrushTool.RaiseLower ||
                    PolyEditor.instance.tool == BrushTool.Smooth)
                {
                    if (s_RebuildNormals.value && (modifiedChannels & MeshChannel.Position) > 0)
                    {
                        PolyMeshUtility.RecalculateNormals(editMesh);
                    }

                    if (optimize)
                    {
                        graphicsMesh.RecalculateBounds();
                        UpdateMeshCollider();
                    }
                }

                editMesh.ApplyAttributesToUnityMesh(graphicsMesh, modifiedChannels);
                graphicsMesh.UploadMeshData(false);
                EditorUtility.SetDirty(gameObjectAttached.GetComponent <Renderer>());

                if (m_PolybrushMesh.componentsCache.MeshFilter)
                {
                    Undo.RecordObject(m_PolybrushMesh.componentsCache.MeshFilter, "Assign Polymesh to MeshFilter");
                }

                if (m_PolybrushMesh)
                {
                    m_PolybrushMesh.SynchronizeWithMeshRenderer();
                }
            }


#if PROBUILDER_4_0_OR_NEWER
            // if it's a probuilder object rebuild the mesh without optimization
            if (isProBuilderObject)
            {
                ProBuilderBridge.SetPositions(gameObjectAttached, editMesh.vertices);
                ProBuilderBridge.SetTangents(gameObjectAttached, editMesh.tangents);

                if (editMesh.colors != null && editMesh.colors.Length == editMesh.vertexCount)
                {
                    Color[] colors = System.Array.ConvertAll(editMesh.colors, x => (Color)x);
                    ProBuilderBridge.SetColors(gameObjectAttached, colors);
                }

                if (rebuildMesh)
                {
                    ProBuilderBridge.ToMesh(gameObjectAttached);
                    ProBuilderBridge.Refresh(gameObjectAttached,
                                             optimize
                            ? ProBuilderBridge.RefreshMask.All
                            : (ProBuilderBridge.RefreshMask.Colors
                               | ProBuilderBridge.RefreshMask.Normals
                               | ProBuilderBridge.RefreshMask.Tangents));
                }
            }
#endif

            if (m_PolybrushMesh.mode == PolybrushMesh.Mode.AdditionalVertexStream)
            {
                modifiedChannels = MeshChannel.Null;
                return;
            }

            if (PolyEditor.instance.tool == BrushTool.RaiseLower ||
                PolyEditor.instance.tool == BrushTool.Smooth)
            {
                if (s_RebuildNormals.value)// && (modifiedChannels & MeshChannel.Position) > 0)
                {
                    PolyMeshUtility.RecalculateNormals(editMesh);
                }

                if (optimize)
                {
                    UpdateMeshCollider();
                    graphicsMesh.RecalculateBounds();
                }
            }

            editMesh.ApplyAttributesToUnityMesh(graphicsMesh, modifiedChannels);

            if (m_PolybrushMesh.componentsCache.MeshFilter)
            {
                Undo.RecordObject(m_PolybrushMesh.componentsCache.MeshFilter, "Assign Polymesh to MeshFilter");
            }

            m_PolybrushMesh.SynchronizeWithMeshRenderer();

            modifiedChannels = MeshChannel.Null;
        }