Exemple #1
0
        static public void AutoSetAtlasContents()
        {
            DirectoryInfo TarDirInfo = new DirectoryInfo(TarPath);
            var           allFiles   = TarDirInfo.GetFiles("*.spriteatlas", SearchOption.AllDirectories);

            foreach (FileInfo nFile in allFiles)
            {
                File.Delete(nFile.FullName);
            }

            DirectoryInfo rootDirInfo = new DirectoryInfo(OprPath);

            DirectoryInfo[] dirs = rootDirInfo.GetDirectories();

            AtlasConfigAsset   configAsset;
            List <AtlasConfig> configs;

            if (File.Exists(AtlasCongigPath))
            {
                configAsset = AssetDatabase.LoadAssetAtPath <AtlasConfigAsset>(AtlasCongigPath);
                configs     = new List <AtlasConfig>(configAsset.Configs);
            }
            else
            {
                configAsset = new AtlasConfigAsset();
                configs     = new List <AtlasConfig>();
            }

            int time = TimeUtility.GetTimeStampEx();

            foreach (DirectoryInfo dirInfo in dirs)
            {
                GeneratePerAtlas(dirInfo);
                if (configs.Find(p => p.Name == dirInfo.Name) == null)
                {
                    AtlasConfig config = new AtlasConfig();
                    config.ID   = time++;
                    config.Name = dirInfo.Name;
                    configs.Add(config);
                }
            }
            configAsset.Configs = configs.ToArray();
            if (File.Exists(AtlasCongigPath))
            {
                EditorUtility.SetDirty(configAsset);
            }
            else
            {
                AssetDatabase.CreateAsset(configAsset, AtlasCongigPath);
            }

            StringBuilder sb = new StringBuilder();

            sb.AppendLine("AtlasConfig =");
            sb.AppendLine("{");
            for (int i = 0; i < configs.Count; i++)
            {
                sb.AppendLine($"\t{configs[i].Name} = {configs[i].ID},");
            }
            sb.AppendLine("}");
            if (!File.Exists(LuaAtlasConfigPath))
            {
                //File.Delete(LuaAtlasConfigPath);
                File.Create(LuaAtlasConfigPath);
            }
            File.WriteAllText(LuaAtlasConfigPath, sb.ToString());

            //DirectoryInfo BigTexDirInfo = new DirectoryInfo(BigTexPath);
            //var allBigTexs = BigTexDirInfo.GetFiles("*.png", SearchOption.AllDirectories);
            //foreach (FileInfo pngFile in allBigTexs)
            //{
            //    string curName = pngFile.Name;
            //    int index = curName.IndexOf(".png");
            //    string ReName = "BigTex_" + curName.Substring(0, index);

            //    var FileName = TarPath + ReName;
            //    if (Directory.Exists(FileName))
            //    {
            //        Directory.Delete(FileName, true);
            //    }
            //    Directory.CreateDirectory(FileName);
            //    var AtlasName = FileName + "/" + ReName + ".spriteatlas";
            //    SpriteAtlas atlas = new SpriteAtlas();
            //    AssetDatabase.CreateAsset(atlas, AtlasName);
            //    AtlasSetting(atlas);
            //    string str = pngFile.FullName.Substring(pngFile.FullName.IndexOf("Assets"));
            //    atlas.Add(new[] { AssetDatabase.LoadAssetAtPath<Sprite>(str) });
            //    AssetDatabase.SaveAssets();
            //}
        }
        private void GenUIConfig(Dictionary <Transform, string> goPathDic)
        {
            GUILayout.Space(10);
            var curSelectedParentPrefab = PrefabUtility.GetCorrespondingObjectFromSource(mUIView.gameObject);
            var uiPath = AssetDatabase.GetAssetPath(curSelectedParentPrefab).Replace("Assets/AssetRes/", "");


            UIConfigAsset uiConfigAsset = AssetDatabase.LoadAssetAtPath <UIConfigAsset>(UIPathAssetPath);

            if (!uiConfigAsset)
            {
                uiConfigAsset         = new UIConfigAsset();
                uiConfigAsset.Configs = new UIConfig[0];
            }


            UIConfig uiConfig = null;

            for (int i = 0; i < uiConfigAsset.Configs.Length; i++)
            {
                UIConfig tmpConfig = uiConfigAsset.Configs[i];
                if (tmpConfig.Name == UIName)
                {
                    uiConfig = tmpConfig;
                    if (uiConfig.ID == 0)
                    {
                        uiConfig.ID = TimeUtility.GetTimeStampEx();
                    }
                    uiConfig.Path = uiPath;
                    break;
                }
            }

            if (uiConfig == null)
            {
                uiConfig      = new UIConfig();
                uiConfig.ID   = TimeUtility.GetTimeStampEx();
                uiConfig.Path = uiPath;
                List <UIConfig> configs = new List <UIConfig>(uiConfigAsset.Configs);
                configs.Add(uiConfig);
                uiConfigAsset.Configs = configs.ToArray();
            }
            uiConfig.SceneName  = SceneIndex == 0 ? string.Empty : SceneNames[SceneIndex];
            uiConfig.AtlasNames = GetAtlasNames(goPathDic);
            if (File.Exists(UIPathAssetPath))
            {
                EditorUtility.SetDirty(uiConfigAsset);
            }
            else
            {
                AssetDatabase.CreateAsset(uiConfigAsset, UIPathAssetPath);
            }

            string filePath = "";

            switch (mUIView.ViewType)
            {
            case UIType.CommonView:
            case UIType.TabView:
                filePath = UIConfigPath;
                break;

            case UIType.Tips:
                filePath = TipsConfigPath;
                break;

            default:
                break;
            }
            if (File.Exists(filePath))
            {
                string[] lines   = File.ReadAllLines(filePath);
                int      uiIndex = -1;
                for (int i = 0; i < lines.Length; i++)
                {
                    if (lines[i].Contains(UIName))
                    {
                        uiIndex = i;
                        break;
                    }
                }
                string newLine = "";
                switch (mUIView.ViewType)
                {
                case UIType.CommonView:
                case UIType.TabView:
                    newLine = $"\t{UIName} = {"{"} Name = \"{UIName}\", " +
                              $"ID = {uiConfig.ID}, " +
                              $"View = \"Logic/UI/View/{UIName}/{UIName}\", " +
                              $"Layer = LayerGroup.{LayerNames[mUIView.LayerIndex]},  " +
                              $"IsTransParent = {mUIView.IsTransParent.ToString().ToLower()},  " +
                              $"ShowMoneyBar = {mUIView.ShowMoneyBar.ToString().ToLower()},  " +
                              $"DestroyWhenUnload = {mUIView.DestroyOnUnload.ToString().ToLower()} {"}"},";
                    break;

                case UIType.Tips:
                    newLine = $"\t{UIName} = {"{"} Name = \"{UIName}\", " +
                              $"ID = {uiConfig.ID} , View = \"Logic/UI/View/{UIName}/{UIName}\"{"}"},";
                    break;

                default:
                    break;
                }

                EditorUtility.SetDirty(mUIView);
                PrefabUtility.ApplyPrefabInstance(mUIView.gameObject, InteractionMode.AutomatedAction);
                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();

                if (uiIndex >= 0)
                {
                    lines[uiIndex] = newLine;
                    File.WriteAllLines(filePath, lines);
                }
                else
                {
                    string[] newLines = new string[lines.Length + 1];
                    Array.Copy(lines, newLines, lines.Length - 1);
                    newLines[lines.Length - 1] = newLine;
                    newLines[lines.Length]     = "}";
                    File.WriteAllLines(filePath, newLines);
                }
            }
        }