public void SaveMesh(string _saveToRelativeFolder, bool _isDeleteAllMeshUnderFolderFirst)
        {
            try
            {
                if (_isDeleteAllMeshUnderFolderFirst)
                {
                    var fullPath = Application.dataPath + _saveToRelativeFolder;
                    if (Directory.Exists(fullPath))
                    {
                        Directory.Delete(fullPath, true);
                    }

                    Directory.CreateDirectory(fullPath);
                }


                var meshList = mTxmMapGo.GetComponentsInChildren <MeshFilter>();
                var index    = 0;
                var totalNum = meshList.Length;
                foreach (var meshFilter in meshList)
                {
                    index++;
#if UNITY_EDITOR
                    UnityEditor.EditorUtility.DisplayProgressBar("Save Mesh", string.Format("Saving mesh : {0}/{1}", index, totalNum), (float)index / totalNum);
#endif
                    meshFilter.sharedMesh = ITU_FIleUtils.SaveMesh(meshFilter.sharedMesh, _saveToRelativeFolder, mTxmMapGo.name + "_Mesh_" + index);
                }
#if UNITY_EDITOR
                UnityEditor.AssetDatabase.SaveAssets();
                UnityEditor.AssetDatabase.Refresh();
#endif
            }
            finally
            {
#if UNITY_EDITOR
                UnityEditor.EditorUtility.ClearProgressBar();
#endif
            }
        }
예제 #2
0
        public void RenderMapToCurrentScene()
        {
            if (mMapMeta == null)
            {
                Debug.LogError("ITU_Facade not load any map, please call LoadTxmFile function first");
                return;
            }


            try
            {
                if (mRenderSetting == null)
                {
                    Debug.LogWarning("not set rendering setting , use default rending setting inside");
                    mRenderSetting = new ITU_RenderSetting();
                    mRenderSetting.SetSaveToFolder("/ITU_DefaultProject", mMapMeta.fileName);
                }

                if (mRenderSetting.renderChunkSize <= 0)
                {
                    mRenderSetting.renderChunkSize = 10;
                    Debug.LogWarning("render setting -> renderChunkSize size <=0  set as default value 10");
                }

                if (mRenderSetting.pixelsPreUnit <= 0)
                {
                    mRenderSetting.pixelsPreUnit = 100;
                    Debug.LogWarning("render setting -> pixelsPreUnit unit <=0 set as default value 100");
                }


                if (mMapMeta.orientation != ITU_TmxRootMeta.ORIENTAION_STAGGERED && mMapMeta.orientation != ITU_TmxRootMeta.ORIENTATION_ISOMETRIC)
                {
                    Debug.LogError(string.Format("Can't render map {0}, beacuse is not Isometric or Staggered. ITU only support those two type right now :( ", mMapMeta.fileName));
                    return;
                }

                if (SortingLayer.NameToID(mRenderSetting.defaultSortLayerName) == 0)
                {
                    foreach (var layerMeta in mMapMeta.layerList)
                    {
                        var    layerName = layerMeta.layerName;
                        string sortLayerName;
                        var    isFound = false;
                        if (mRenderSetting.customSortLayerDic.TryGetValue(layerName, out sortLayerName))
                        {
                            if (SortingLayer.NameToID(sortLayerName) != 0)
                            {
                                isFound = true;
                            }
                        }

                        if (!isFound)
                        {
                            Debug.LogError(string.Format(
                                               "Can't find default sort layer <color=red> {1} </color> and no sortLayer define for Tiled layer <color=red> {0} </color>," +
                                               "please first define it in <color=red>Edit -> Project Settings -> Tags and Layers</color> " +
                                               "check the document under $ITU_Plugin_Folder/Document if you need more help",
                                               layerName, mRenderSetting.defaultSortLayerName));
                            return;
                        }
                    }
                }


                mAllExtensionList.ForEach(x =>
                {
                    x.SetRenderSetting(mRenderSetting);
                    x.SetTmxMapMeta(mMapMeta);
                });


                var render = new ITU_TmxRender();
                render.InitTxmRender(mMapMeta, mRenderSetting, mAllExtensionList);

                mMapMeta.tilsetList.ForEach(tileset =>
                {
                    if (!tileset.isUesdInRender || tileset.isImageCollectionAndNotRender)
                    {
                        return;
                    }

                    Material matTemplate;
                    if (!mRenderSetting.tilesetMaterials.TryGetValue(tileset.name, out matTemplate))
                    {
                        matTemplate = mRenderSetting.defaultMaterial;
                    }

                    var mat = ITU_FIleUtils.SaveTilsetImageAndMaterial(tileset, matTemplate,
                                                                       mRenderSetting.imgSaveToPath,
                                                                       mRenderSetting.materailSaveToPath);

                    mRenderSetting.tilesetMaterials.Add(tileset.name, mat);
                });

                mAllExtensionList.ForEach(x => x.OnRenderMapProcessBegin());
                var go = render.RenderTxmToScene();
                mAllExtensionList.ForEach(x => x.OnRenderMapProcessFinish(go));


                //Save Mesh
                render.SaveMesh(mRenderSetting.meshSaveToPath, mRenderSetting.isDeleteAllMeshUnderFolderFirst);

                if (mRenderSetting.isMakeAllGameObjectStatic)
                {
                    render.MakeAllStatic();
                }

                //Save Prefab
                var prefab = render.SavePrefab(mRenderSetting.prefabSaveToPath);

                //Delte templet go
                GameObject.DestroyImmediate(go);

                if (mRenderSetting.isCreateInstanceOnSceneWhenFinish)
                {
                    PrefabUtility.InstantiatePrefab(prefab);
                }

                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();
            }
            catch (Exception _e)
            {
                var msg = "Oops ,seemed there have been some error when you run ITU, if you need some help you can contact me via [email protected]";
                Debug.LogError(msg);
                Debug.LogError(_e);
                return;
            }

            Debug.Log(string.Format("<color=green>ITU import {0} succeed! </color>", mMapMeta.fileName));
        }
 /// <summary>
 /// Save mTxmMapGo as a prefab,and return the Prefab reference
 /// </summary>
 /// <param name="_saveToRelativeFolder">the foler you want save, relate to project folder e.g "/Demo" </param>
 /// <returns></returns>
 public GameObject SavePrefab(string _saveToRelativeFolder)
 {
     return(ITU_FIleUtils.SavePrefab(mTxmMapGo, _saveToRelativeFolder, mRenderSetting.prefabSaveName == null ? mTxmMapGo.name : mRenderSetting.prefabSaveName));
 }