void OnComputeMesh()
 {
     for (int i = 0; i < computeMeshGoList.Count; i++)
     {
         //1.清除原来的数据
         GameObject   go       = computeMeshGoList[i];
         MeshSimplify simplify = go.GetComponent <MeshSimplify>();
         if (go == null || simplify == null)
         {
             continue;
         }
         simplify.RestoreOriginalMesh(true, simplify.m_meshSimplifyRoot == null);
         RemoveChildMeshSimplifyComponents(simplify);
         //2.开始计算
         try
         {
             if (simplify.DataDirty || simplify.HasData() == false || simplify.HasNonMeshSimplifyGameObjectsInTree())
             {
                 simplify.RestoreOriginalMesh(true, simplify.m_meshSimplifyRoot == null);
                 bool mMeshSimplefyRoot = simplify.m_meshSimplifyRoot == null;
                 simplify.ComputeData(mMeshSimplefyRoot, null);
             }
         }
         catch (System.Exception e)
         {
             Debug.LogError("Error generating mesh: " + e.Message + " Stack: " + e.StackTrace);
             EditorUtility.ClearProgressBar();
             Simplifier.Cancelled = false;
         }
         //3.最后应用Prefab
     }
     isClickButton = true;
 }
    bool SaveMeshAssetsRecursive(GameObject root, GameObject gameObject, string strFile, bool bRecurseIntoChildren, bool bAssetAlreadyCreated, ref int nProgressElementsCounter)
    {
        if (gameObject == null || Simplifier.Cancelled)
        {
            return(bAssetAlreadyCreated);
        }

        MeshSimplify meshSimplify = gameObject.GetComponent <MeshSimplify>();

        if (meshSimplify != null && meshSimplify.HasData() && (meshSimplify.MeshSimplifyRoot == null || meshSimplify.MeshSimplifyRoot.gameObject == root))
        {
            int nTotalProgressElements = meshSimplify.MeshSimplifyRoot != null ? (meshSimplify.MeshSimplifyRoot.ListDependentChildren.Count + 1) : 1;

            if (meshSimplify.SimplifiedMesh != null && MeshUtil.HasValidMeshData(meshSimplify.gameObject))
            {
                float fT = (float)nProgressElementsCounter / (float)nTotalProgressElements;
                Progress("Saving meshes to asset file", meshSimplify.name, fT);

                if (Simplifier.Cancelled)
                {
                    return(bAssetAlreadyCreated);
                }

                if (bAssetAlreadyCreated == false /* && UnityEditor.AssetDatabase.Contains(meshSimplify.m_simplifiedMesh) == false*/)
                {
                    //Debug.Log("Creating asset " + meshSimplify.m_simplifiedMesh.name);

                    UnityEditor.AssetDatabase.CreateAsset(meshSimplify.SimplifiedMesh, strFile);
                    Resources.UnloadAsset(meshSimplify.SimplifiedMesh);
                    meshSimplify.SimplifiedMesh = null;
                    bAssetAlreadyCreated        = true;
                }
                else
                {
                    //if (UnityEditor.AssetDatabase.Contains(meshSimplify.m_simplifiedMesh) == false)
                    {
                        //Debug.Log("Adding asset " + meshSimplify.m_simplifiedMesh.name);

                        UnityEditor.AssetDatabase.AddObjectToAsset(meshSimplify.SimplifiedMesh, strFile);
                        UnityEditor.AssetDatabase.ImportAsset(UnityEditor.AssetDatabase.GetAssetPath(meshSimplify.SimplifiedMesh));
                    }
                }

                nProgressElementsCounter++;
            }
        }

        if (bRecurseIntoChildren)
        {
            for (int nChild = 0; nChild < gameObject.transform.childCount; nChild++)
            {
                bAssetAlreadyCreated = SaveMeshAssetsRecursive(root, gameObject.transform.GetChild(nChild).gameObject, strFile, bRecurseIntoChildren, bAssetAlreadyCreated, ref nProgressElementsCounter);
            }
        }

        return(bAssetAlreadyCreated);
    }
Esempio n. 3
0
    private IEnumerator ComputeMeshWithVertices(float fAmount)
    {
        Simplifier.CoroutineFrameMiliseconds = 20;

        foreach (KeyValuePair <GameObject, Material[]> pair in m_objectMaterials)
        {
            MeshSimplify        meshSimplify = pair.Key.GetComponent <MeshSimplify>();
            MeshFilter          meshFilter   = pair.Key.GetComponent <MeshFilter>();
            SkinnedMeshRenderer skin         = pair.Key.GetComponent <SkinnedMeshRenderer>();

            if (meshSimplify == null)
            {
                meshSimplify = pair.Key.AddComponent <MeshSimplify>();
                meshSimplify.m_meshSimplifyRoot = m_selectedMeshSimplify;
                m_selectedMeshSimplify.m_listDependentChildren.Add(meshSimplify);
            }

            if (meshSimplify.MeshSimplifier == null)
            {
                meshSimplify.MeshSimplifier           = meshSimplify.gameObject.AddComponent <Simplifier>();
                meshSimplify.MeshSimplifier.hideFlags = HideFlags.HideInInspector;
                meshSimplify.ConfigureSimplifier();
            }

            if (meshSimplify && MeshSimplify.HasValidMeshData(pair.Key))
            {
                Mesh newMesh = null;

                if (meshFilter != null)
                {
                    newMesh = Mesh.Instantiate(meshFilter.sharedMesh);
                }
                else if (skin != null)
                {
                    newMesh = Mesh.Instantiate(skin.sharedMesh);
                }

                if (meshSimplify.HasData() == false)
                {
                    meshSimplify.GetMeshSimplifier().CoroutineEnded = false;

                    StartCoroutine(meshSimplify.GetMeshSimplifier().ProgressiveMesh(pair.Key, meshFilter != null ? meshFilter.sharedMesh : skin.sharedMesh, null, meshSimplify.name, Progress));

                    while (meshSimplify.GetMeshSimplifier().CoroutineEnded == false)
                    {
                        yield return(null);
                    }
                }

                if (meshSimplify.GetMeshSimplifier() != null)
                {
                    meshSimplify.GetMeshSimplifier().CoroutineEnded = false;

                    StartCoroutine(meshSimplify.GetMeshSimplifier().ComputeMeshWithVertexCount(pair.Key, newMesh, Mathf.RoundToInt(fAmount * meshSimplify.GetMeshSimplifier().GetOriginalMeshUniqueVertexCount()), meshSimplify.name, Progress));

                    while (meshSimplify.GetMeshSimplifier().CoroutineEnded == false)
                    {
                        yield return(null);
                    }

                    if (meshFilter != null)
                    {
                        meshFilter.mesh = newMesh;
                    }
                    else if (skin != null)
                    {
                        skin.sharedMesh = newMesh;
                    }

                    meshSimplify.m_simplifiedMesh = newMesh;
                }
            }
        }

        m_bFinished = true;
    }