Exemplo n.º 1
0
        public virtual void Build()
        {
            Clear();

            var buildList = GetBuildList();

            if (buildList != null && buildList.Count > 0)
            {
                BuildAssetBundleOptions bundleOptions;//打包设置:
                bundleOptions  = BuildAssetBundleOptions.None;
                bundleOptions |= BuildAssetBundleOptions.ChunkBasedCompression;
                bundleOptions |= BuildAssetBundleOptions.DeterministicAssetBundle;
                bundleOptions |= BuildAssetBundleOptions.DisableLoadAssetByFileName;
                bundleOptions |= BuildAssetBundleOptions.DisableLoadAssetByFileNameWithExtension;

                var buildExportPath = AssetBuildConfiger.GetInstance().GetExportFolderPath();
                var buildPlatform   = AssetBuildConfiger.GetInstance().GetBuildType();

                if (!XFolderTools.Exists(buildExportPath))
                {
                    XFolderTools.CreateDirectory(buildExportPath);
                }

                BuildPipeline.BuildAssetBundles(buildExportPath, buildList.ToArray(), bundleOptions, buildPlatform);
            }
        }
Exemplo n.º 2
0
        private Dictionary <string, Item> _dictByMd5;  //字典

        public AssetUpdateAssetList Scan(string assetFolder)
        {
            if (string.IsNullOrEmpty(assetFolder))
            {
                return(this);
            }

            var assetFolderLow = assetFolder.ToLower();
            var fileList       = new List <Item>();

            XFolderTools.TraverseFiles(assetFolder, (fullPath) =>
            {
                var assetPath = XPathTools.GetRelativePath(fullPath);
                var relaPath  = XPathTools.SubRelativePath(assetFolder, assetPath);

                var updateItem      = new Item();
                updateItem.filePath = relaPath.ToLower();
                updateItem.fileMd5  = XFileTools.GetMD5(assetPath);
                updateItem.fileSize = XFileTools.GetLength(assetPath);

                fileList.Add(updateItem);
            }, true);

            path      = assetFolder;
            fileItems = fileList.ToArray();
            return(this);
        }
Exemplo n.º 3
0
 public static void TryCreateFolder(string path)
 {
     if (!XFolderTools.Exists(path))
     {
         XFolderTools.CreateDirectory(path);
     }
 }
Exemplo n.º 4
0
        public void Freeze(int version)
        {
            if (version <= 0)
            {
                return;
            }

            var repositoryRoot = AssetSyncConfiger.GetInstance().GetRepositoryRootPath();

            if (string.IsNullOrEmpty(repositoryRoot))
            {
                return;
            }

            var syncItems = AssetSyncConfiger.GetInstance().syncItems;

            if (syncItems == null || syncItems.Count <= 0)
            {
                return;
            }

            string versionFolderName = string.Format("{0}", version);
            string repositoryPath    = XPathTools.Combine(repositoryRoot, versionFolderName);

            foreach (var syncItem in syncItems)
            {
                string destPath = XPathTools.Combine(repositoryPath, syncItem.realSearcePath);
                if (XFolderTools.Exists(destPath))
                {
                    XFolderTools.DeleteDirectory(destPath, true);
                }
            }
        }
Exemplo n.º 5
0
        public static void GenPrefabAndmaterial(string assetPath, List <string> exportPathList = null)
        {
            if (exportPathList == null)
            {
                exportPathList = new List <string>();
                string selectRootPath = Path.GetDirectoryName(assetPath);
                string selectFileName = Path.GetFileNameWithoutExtension(assetPath);
                XFolderTools.TraverseFiles(selectRootPath, (fullPath) =>
                {
                    string fileEx = Path.GetExtension(fullPath).ToLower();
                    if (fileEx.Contains("controller"))
                    {
                        string fleRelaPath  = XPathTools.GetRelativePath(fullPath);
                        string fileRootPath = Path.GetDirectoryName(fleRelaPath);

                        exportPathList.Add(fileRootPath);
                    }
                }, true);
            }
            foreach (var exportRootPath in exportPathList)
            {
                string ctrlFilePath = XPathTools.Combine(exportRootPath, SpriteEditorTools.controllerName);

                string folderId         = XStringTools.SplitPathKey(exportRootPath);
                string spriteSavePath   = XPathTools.Combine(exportRootPath, string.Format("{0}.prefab", folderId));
                string materialSavePath = XPathTools.Combine(exportRootPath, string.Format("{0}.mat", folderId));
                var    sprite           = SpriteEditorTools.GeneratePrefabFromAnimationControllerFile(ctrlFilePath, spriteSavePath);
                var    material         = SpriteEditorTools.GenerateMaterialFromAnimationControllerFile(ctrlFilePath, materialSavePath);

                SpriteEditorTools.SetupMaterial(sprite, material);
                SpriteEditorTools.SetupBoxCollider(sprite);
                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// 从选择项中获取路径
        /// </summary>
        /// <param name="suffixs"></param>
        /// <param name="isTrans"></param>
        /// <returns></returns>
        public static string[] GetPathsBySelections(string[] suffixs = null, bool isTraverse = false)
        {
            var           selectedObjs = Selection.objects;
            List <string> retPathList  = new List <string>();

            if (selectedObjs != null && selectedObjs.Length > 0)
            {
                List <string> filePathList = new List <string>();
                foreach (var selected in selectedObjs)
                {
                    string selectPath = AssetDatabase.GetAssetPath(selected);
                    if (File.Exists(selectPath))            //如果是文件
                    {
                        filePathList.Add(selectPath);
                    }
                    else if (Directory.Exists(selectPath))   //如果是文件夹
                    {
                        XFolderTools.TraverseFiles(selectPath, (fullPath) =>
                        {
                            string realPath = XPathTools.GetRelativePath(fullPath);
                            filePathList.Add(realPath);
                        }, isTraverse);
                    }
                }

                //筛选
                HashSet <string> suffixSet = null;
                if (suffixs != null && suffixs.Length > 0)
                {
                    suffixSet = new HashSet <string>();
                    foreach (var suffix in suffixs)
                    {
                        string lowSuffix = suffix.ToLower();
                        if (!suffixSet.Contains(lowSuffix))
                        {
                            suffixSet.Add(lowSuffix);
                        }
                    }
                }


                foreach (var path in filePathList)
                {
                    if (suffixSet != null)
                    {
                        string fileExtName = Path.GetExtension(path).ToLower();
                        if (suffixSet.Contains(fileExtName))
                        {
                            retPathList.Add(path);
                        }
                    }
                    else
                    {
                        retPathList.Add(path);
                    }
                }
            }
            return(retPathList.ToArray());
        }
Exemplo n.º 7
0
        private void ImportExAsset(string folderPath)
        {
            _assetFolderPath = folderPath;
            _assetFolderList = new List <string>();

            XFolderTools.TraverseFiles(_assetFolderPath, (fullPath) =>
            {
                string exName = Path.GetExtension(fullPath);
                _assetFolderList.Add(fullPath);
            }, true);

            RefreshAssetList();
        }
Exemplo n.º 8
0
 public void Sync()
 {
     //遍历版本库文件夹
     XFolderTools.TraverseFolder(AssetSyncConfiger.GetInstance().GetRepositoryRootPath(), (fullPath) =>
     {
         string folderName = Path.GetFileNameWithoutExtension(fullPath);
         int version;
         if (int.TryParse(folderName, out version))
         {
             Sync(version);
         }
     });
 }
Exemplo n.º 9
0
 //拆成10个
 public static void SaveAllLevelPrefabs(GameObject srcGO, string savePath)
 {
     if (srcGO)
     {
         string effectId  = XStringTools.SplitPathKey(srcGO.name);
         string finalPath = Path.Combine(savePath, effectId);
         if (!XFolderTools.Exists(finalPath))
         {
             XFolderTools.CreateDirectory(finalPath);
         }
         for (int i = 1; i <= EffectLevelUtil.MAX_LEVEL; i++)
         {
             string saveName = Path.Combine(finalPath, string.Format("{0}_{1:D2}.prefab", effectId, i));
             SavePrefabByLevel(srcGO, saveName, i);
         }
     }
 }
Exemplo n.º 10
0
        //获取目录下第一个文件的后缀
        private string GetFolderFirstFileExtension(string folderPath)
        {
            string ex = "";

            XFolderTools.TraverseFiles(folderPath, (fullPath) =>
            {
                if (!string.IsNullOrEmpty(ex))
                {
                    return;
                }

                ex = Path.GetExtension(fullPath);
                if (ex.Contains("DS_Store"))
                {
                    ex = "";
                }
            });
            return(ex);
        }
Exemplo n.º 11
0
        static T GetOrCreateAsset()
        {
            T asset = null;

            if (XFileTools.Exists(_configAssetsPath))
            {
                asset = AssetDatabase.LoadAssetAtPath <T>(_configAssetsPath);
            }
            else
            {
                asset = ScriptableObject.CreateInstance <T>();
                if (!XFolderTools.Exists(_saveFolder))
                {
                    XFolderTools.CreateDirectory(_saveFolder);
                }
                AssetDatabase.CreateAsset(asset, _configAssetsPath);
                AssetDatabase.Refresh();
            }
            return(asset);
        }
Exemplo n.º 12
0
        private void DoStart()
        {
            _assetMap.Clear();
            _checkfilePath2srcAssetPath.Clear();
            _processPath2srcAssetPath.Clear();

            string processFolderPath = AssetProcesserConfiger.GetInstance().GetProcessFloderPath();

            if (!XFolderTools.Exists(processFolderPath))
            {
                XFolderTools.CreateDirectory(processFolderPath);
            }

            string outputPath = AssetProcesserConfiger.GetInstance().GetProcessSaveFolderPath(_progresersName);

            if (!XFolderTools.Exists(outputPath))
            {
                XFolderTools.CreateDirectory(outputPath);
            }

            OnStart();
        }
Exemplo n.º 13
0
        public static void MenuGenSheetJson()
        {
            var    selected   = Selection.activeObject;
            string selectPath = AssetDatabase.GetAssetPath(selected);

            if (selectPath != "")
            {
                List <string> assetsList = new List <string>();
                if (Directory.Exists(selectPath))    //是文件夹
                {
                    //对所有操作
                    XFolderTools.TraverseFiles(selectPath, (fullPath) =>
                    {
                        string fileNameNExt = Path.GetFileNameWithoutExtension(fullPath).ToLower();
                        string fileExt      = Path.GetExtension(fullPath).ToLower();

                        if (!AssetRuntimeUtil.IsImageFile(fullPath))
                        {
                            return;
                        }

                        string assetPath = XPathTools.GetRelativePath(fullPath);
                        assetsList.Add(assetPath);
                    });
                }
                else
                {
                    assetsList.Add(selectPath);
                }
                foreach (var assetPath in assetsList)
                {
                    GenSheetJson(assetPath);
                }
            }
            else
            {
                Debug.LogError("没有选中文件或文件夹");
            }
        }
Exemplo n.º 14
0
        protected bool SaveCheckfile(string srcPath, AssetProcessCheckfile checkfile)
        {
            if (checkfile == null)
            {
                return(false);
            }

            string checkfileSavePath = GetCheckfilePath(srcPath);

            if (!XFileTools.Exists(checkfileSavePath))
            {
                string checkfileParentPath = Path.GetDirectoryName(checkfileSavePath);
                if (!XFolderTools.Exists(checkfileParentPath))
                {
                    XFolderTools.CreateDirectory(checkfileParentPath);
                }
            }

            AssetDatabase.DeleteAsset(checkfileSavePath);
            AssetDatabase.CreateAsset(checkfile, checkfileSavePath);

            return(true);
        }
Exemplo n.º 15
0
        private void BuildAll()
        {
            Build4Common();
            Build4Custom();
            Build4Share();

            BuildAssetBundleOptions bundleOptions;//打包设置:

            bundleOptions  = BuildAssetBundleOptions.None;
            bundleOptions |= BuildAssetBundleOptions.ChunkBasedCompression;
            bundleOptions |= BuildAssetBundleOptions.DeterministicAssetBundle;
            bundleOptions |= BuildAssetBundleOptions.DisableLoadAssetByFileName;
            bundleOptions |= BuildAssetBundleOptions.DisableLoadAssetByFileNameWithExtension;

            var buildExportPath = AssetBuildConfiger.GetInstance().GetExportFolderPath();
            var buildPlatform   = AssetBuildConfiger.GetInstance().GetBuildType();

            if (!XFolderTools.Exists(buildExportPath))
            {
                XFolderTools.CreateDirectory(buildExportPath);
            }

            BuildPipeline.BuildAssetBundles(buildExportPath, GetBuildsArray(), bundleOptions, buildPlatform);
        }
Exemplo n.º 16
0
        private void DoEnd()
        {
            //处理无效的Checkfile文件
            string checkfileFolderPath     = AssetProcesserConfiger.GetInstance().GetCheckfileSaveFolderPath(_progresersName); //TODO:这里如果全部放到一个路径下,会被别的干扰到了
            bool   isUseGUID               = AssetProcesserConfiger.GetInstance().useGUID4SaveCheckfileName;
            bool   createFolderOrAddSuffix = AssetProcesserConfiger.GetInstance().createFolderOrAddSuffix;

            XFolderTools.TraverseFiles(checkfileFolderPath, (fullPath) =>
            {
                string exName = Path.GetExtension(fullPath).ToLower();
                if (exName.Contains("meta"))
                {
                    return;
                }

                string realPath    = XPathTools.GetRelativePath(fullPath); //路径做Key,有的资源可能名字相同
                string realPathLow = realPath.ToLower();
                if (isUseGUID)
                {
                    string srcPath = AssetDatabase.GUIDToAssetPath(realPath);

                    if (string.IsNullOrEmpty(srcPath) || !_assetMap.ContainsKey(realPathLow))
                    {
                        XFileTools.Delete(fullPath);
                    }
                }
                else
                {
                    bool canDelete = true;
                    if (!createFolderOrAddSuffix)
                    {
                        string fileNameWithoutEx = Path.GetFileNameWithoutExtension(realPath);
                        if (!fileNameWithoutEx.EndsWith(_progresersName))
                        {
                            canDelete = false;
                        }
                    }

                    if (canDelete && !_checkfilePath2srcAssetPath.ContainsKey(realPath))
                    {
                        XFileTools.Delete(fullPath);
                    }
                }
            });

            //处理无效输出文件
            string outputFolderPath = AssetProcesserConfiger.GetInstance().GetProcessSaveFolderPath(_progresersName);

            XFolderTools.TraverseFolder(outputFolderPath, (fullPath) =>
            {
                string realPath = XPathTools.GetRelativePath(fullPath);

                string checkKey1 = Path.GetFileNameWithoutExtension(fullPath);
                string checkKey2 = XStringTools.SplitPathKey(fullPath);
                //但凡在名字上有点关系都移除,多重key检测
                if (!_processPath2srcAssetPath.ContainsKey(checkKey1) && !_processPath2srcAssetPath.ContainsKey(checkKey2) && !_processPath2srcAssetPath.ContainsKey(realPath))
                {
                    XFolderTools.DeleteDirectory(fullPath, true);
                }
            });

            XFolderTools.TraverseFiles(outputFolderPath, (fullPath) =>
            {
                string exName = Path.GetExtension(fullPath).ToLower();
                if (exName.Contains("meta"))
                {
                    return;
                }

                string realPath = XPathTools.GetRelativePath(fullPath); //路径做Key,有的资源可能名字相同

                string checkKey1 = Path.GetFileNameWithoutExtension(fullPath);
                string checkKey2 = XStringTools.SplitPathKey(fullPath);
                //但凡在名字上有点关系都移除,多重key检测
                if (!_processPath2srcAssetPath.ContainsKey(checkKey1) && !_processPath2srcAssetPath.ContainsKey(checkKey2) && !_processPath2srcAssetPath.ContainsKey(realPath))
                {
                    XFileTools.Delete(fullPath);
                }
            });


            OnEnd();
        }
Exemplo n.º 17
0
        static void BuildAssembly(bool wait)
        {
            for (int i = 0; i < AssembliesToolsConfig.GetInstance().buildPathList.Count; i++)
            {
                var buildInfo = AssembliesToolsConfig.GetInstance().buildPathList[i];

                if (!string.IsNullOrEmpty(buildInfo.srcPath) && !string.IsNullOrEmpty(buildInfo.buildPath) && !string.IsNullOrEmpty(buildInfo.projectPath))
                {
                    bool[] editorFlags = { true, true, true, true };

                    List <string> csFilePaths = new List <string>();

                    XFolderTools.TraverseFiles(buildInfo.srcPath, (string fullPath) =>
                    {
                        if (Path.GetExtension(fullPath) == ".cs")
                        {
                            csFilePaths.Add(fullPath);
                        }
                    }, true);


                    string srcPathName         = Path.GetFileNameWithoutExtension(buildInfo.srcPath);
                    string outputAssembly      = XPathTools.Combine(buildInfo.buildPath, string.Format("{0}.dll", srcPathName));
                    string assemblyProjectPath = XPathTools.Combine(buildInfo.projectPath, string.Format("{0}.dll", srcPathName));
                    if (csFilePaths.Count > 0)
                    {
                        if (!XFolderTools.Exists(buildInfo.buildPath))
                        {
                            XFolderTools.CreateDirectory(buildInfo.buildPath);
                        }
                        if (!XFolderTools.Exists(buildInfo.projectPath))
                        {
                            XFolderTools.CreateDirectory(buildInfo.projectPath);
                        }

                        bool editorFlag = editorFlags[i];

                        var assemblyBuilder = new AssemblyBuilder(outputAssembly, csFilePaths.ToArray());

                        // Exclude a reference to the copy of the assembly in the Assets folder, if any.
                        assemblyBuilder.excludeReferences = new string[] { assemblyProjectPath };

                        if (editorFlag)
                        {
                            assemblyBuilder.flags = AssemblyBuilderFlags.EditorAssembly;
                        }

                        // Called on main thread
                        assemblyBuilder.buildStarted += delegate(string assemblyPath)
                        {
                            Debug.LogFormat("Assembly build started for {0}", assemblyPath);
                        };

                        // Called on main thread
                        assemblyBuilder.buildFinished += delegate(string assemblyPath, CompilerMessage[] compilerMessages)
                        {
                            foreach (var v in compilerMessages)
                            {
                                if (v.type == CompilerMessageType.Error)
                                {
                                    Debug.LogError(v.message);
                                }
                                else
                                {
                                    Debug.LogWarning(v.message);
                                }
                            }

                            var errorCount   = compilerMessages.Count(m => m.type == CompilerMessageType.Error);
                            var warningCount = compilerMessages.Count(m => m.type == CompilerMessageType.Warning);

                            Debug.LogFormat("Assembly build finished for {0}", assemblyPath);
                            Debug.LogFormat("Warnings: {0} - Errors: {0}", errorCount, warningCount);

                            if (errorCount == 0)
                            {
                                File.Copy(outputAssembly, assemblyProjectPath, true);
                                AssetDatabase.ImportAsset(assemblyProjectPath);
                            }
                        };

                        // Start build of assembly
                        if (!assemblyBuilder.Build())
                        {
                            Debug.LogErrorFormat("Failed to start build of assembly {0}!", assemblyBuilder.assemblyPath);
                            return;
                        }

                        if (wait)
                        {
                            while (assemblyBuilder.status != AssemblyBuilderStatus.Finished)
                            {
                                System.Threading.Thread.Sleep(10);
                            }
                        }
                    }
                    else
                    {
                        XFileTools.Delete(assemblyProjectPath);
                        continue;
                    }
                }
            }
        }
Exemplo n.º 18
0
        public void Sync(int version)
        {
            var syncItems = AssetSyncConfiger.GetInstance().syncItems;

            if (syncItems == null || syncItems.Count <= 0)
            {
                return;
            }

            string fullPath          = XPathTools.Combine(AssetSyncConfiger.GetInstance().repositoryRootPath, string.Format("{0}", version));
            string repositoryPath    = fullPath;
            string versionFolderName = Path.GetFileNameWithoutExtension(fullPath);
            int    curVersion        = AssetSyncConfiger.GetInstance().GetRepositoryVersion(versionFolderName);

            if (curVersion > 0 && curVersion >= AssetSyncConfiger.GetInstance().minVersion)
            {
                foreach (var syncItem in syncItems)
                {
                    string srcPath    = syncItem.srcPath;
                    string searchPath = XPathTools.Combine(repositoryPath, syncItem.realSearcePath);
                    string syncPath   = XPathTools.Combine(repositoryPath, syncItem.realSyncPath);
                    if (XFolderTools.Exists(srcPath) && XFolderTools.Exists(searchPath) && XFolderTools.Exists(syncPath))
                    {
                        List <string> syncFileList   = new List <string>();
                        List <string> syncFolderList = new List <string>();
                        if (syncItem.searchMode == AssetSyncItem.SearchMode.Forward)     //根据搜索文件找资源
                        {
                            string srcEx = GetFolderFirstFileExtension(srcPath);
                            XFolderTools.TraverseFiles(searchPath, (filePath) =>
                            {
                                string fileKey = null;
                                if (syncItem.searchKey == AssetSyncItem.SearchKey.AssetName)
                                {
                                    fileKey = Path.GetFileNameWithoutExtension(filePath);
                                }
                                else if (syncItem.searchKey == AssetSyncItem.SearchKey.AssetPrefix)
                                {
                                    fileKey = XStringTools.SplitPathKey(filePath);
                                }

                                string srcFilePath = XPathTools.Combine(srcPath, string.Format("{0}{1}", fileKey, srcEx));
                                if (XFileTools.Exists(srcFilePath))
                                {
                                    syncFileList.Add(srcFilePath);
                                }
                            });

                            XFolderTools.TraverseFolder(searchPath, (folderPath) =>
                            {
                                string fileKey = null;
                                if (syncItem.searchKey == AssetSyncItem.SearchKey.AssetName)
                                {
                                    fileKey = Path.GetFileNameWithoutExtension(folderPath);
                                }
                                else if (syncItem.searchKey == AssetSyncItem.SearchKey.AssetPrefix)
                                {
                                    fileKey = XStringTools.SplitPathKey(folderPath);
                                }

                                string srcFolderPath = XPathTools.Combine(srcPath, string.Format("{0}", fileKey));
                                if (XFolderTools.Exists(srcFolderPath))
                                {
                                    syncFolderList.Add(srcFolderPath);
                                }
                            });
                        }
                        else if (syncItem.searchMode == AssetSyncItem.SearchMode.Reverse)   //根据资源匹对文件
                        {
                            XFolderTools.TraverseFiles(srcPath, (filePath) =>
                            {
                                string fileKey = null;
                                if (syncItem.searchKey == AssetSyncItem.SearchKey.AssetName)
                                {
                                    fileKey = Path.GetFileNameWithoutExtension(filePath);
                                }
                                else if (syncItem.searchKey == AssetSyncItem.SearchKey.AssetPrefix)
                                {
                                    fileKey = XStringTools.SplitPathKey(filePath);
                                }

                                string searchFilePath = XPathTools.Combine(searchPath, string.Format("{0}", fileKey));
                                if (XFileTools.Exists(searchFilePath))
                                {
                                    syncFileList.Add(filePath);
                                }
                            });

                            XFolderTools.TraverseFolder(srcPath, (folderPath) =>
                            {
                                string fileKey = null;
                                if (syncItem.searchKey == AssetSyncItem.SearchKey.AssetName)
                                {
                                    fileKey = Path.GetFileNameWithoutExtension(folderPath);
                                }
                                else if (syncItem.searchKey == AssetSyncItem.SearchKey.AssetPrefix)
                                {
                                    fileKey = XStringTools.SplitPathKey(folderPath);
                                }

                                string searchFilePath = XPathTools.Combine(searchPath, string.Format("{0}", fileKey));
                                if (XFileTools.Exists(searchFilePath))
                                {
                                    syncFolderList.Add(folderPath);
                                }
                            });
                        }

                        HashSet <string> syncFileDict = new HashSet <string>();
                        foreach (var syncSrcFile in syncFileList)
                        {
                            //把文件拷贝到同步目录
                            string syncFileName = Path.GetFileName(syncSrcFile);
                            string syncDestPath = XPathTools.Combine(syncPath, syncFileName);
                            XFileTools.Delete(syncDestPath);
                            XFileTools.Copy(syncSrcFile, syncDestPath);

                            if (!syncFileDict.Contains(syncDestPath))
                            {
                                syncFileDict.Add(syncDestPath);
                            }
                        }

                        HashSet <string> syncFolderDict = new HashSet <string>();
                        foreach (var syncSrcFolder in syncFolderList)
                        {
                            //把文件拷贝到同步目录
                            string syncFileName = Path.GetFileName(syncSrcFolder);
                            string syncDestPath = XPathTools.Combine(syncPath, syncFileName);

                            XFolderTools.DeleteDirectory(syncDestPath, true);
                            XFolderTools.CopyDirectory(syncSrcFolder, syncDestPath);

                            if (!syncFolderDict.Contains(syncDestPath))
                            {
                                syncFolderDict.Add(syncDestPath);
                            }
                        }

                        //移除不在同步的文件
                        XFolderTools.TraverseFiles(syncPath, (syncFullPath) =>
                        {
                            if (!syncFileDict.Contains(syncFullPath))
                            {
                                XFileTools.Delete(syncFullPath);
                            }
                        });

                        XFolderTools.TraverseFolder(syncPath, (syncFullPath) =>
                        {
                            if (!syncFolderDict.Contains(syncFullPath))
                            {
                                XFolderTools.DeleteDirectory(syncFullPath, true);
                            }
                        });
                    }
                }
            }
        }
Exemplo n.º 19
0
        /// <summary>
        /// 生成动画及控制器
        /// sprite子项命名规则:组_动作名_编号,没有编号的一律不生成Anima
        /// </summary>
        /// <param name="assetPath"></param>
        public static Dictionary <string, Dictionary <string, AnimationClip> > GenerateAnimationClipFromTextureFile(string assetPath, string saveRootPath = "", System.Action <AnimationClip> callback = null)
        {
            string          assetFileNonExtName = Path.GetFileNameWithoutExtension(assetPath);
            string          assetRootPath       = Path.GetDirectoryName(assetPath);
            TextureImporter importer            = LoadImporterFromTextureFile(assetPath);

            if (importer)
            {
                //判断是否是精灵图集
                if (!(importer.textureType == TextureImporterType.Sprite && importer.spriteImportMode == SpriteImportMode.Multiple))
                {
                    return(null);
                }

                //获取所有精灵帧
                Object[] sheetObjs = AssetDatabase.LoadAllAssetsAtPath(assetPath);
                var      sheetDict = new Dictionary <string, Dictionary <string, SortedList <string, SpriteSheetFrameData> > >();
                foreach (var obj in sheetObjs)
                {
                    SpriteSheetFrameData metadata = SpriteSheetFrameData.TryCreate(obj as Sprite);
                    if (metadata != null)
                    {
                        string groupName = metadata.groupName;
                        Dictionary <string, SortedList <string, SpriteSheetFrameData> > actionMaps;
                        if (sheetDict.ContainsKey(groupName))
                        {
                            actionMaps = sheetDict[groupName];
                        }
                        else
                        {
                            actionMaps = new Dictionary <string, SortedList <string, SpriteSheetFrameData> >();
                            sheetDict.Add(groupName, actionMaps);
                        }
                        //
                        string actionName = metadata.actionName;
                        SortedList <string, SpriteSheetFrameData> frameList;
                        if (actionMaps.ContainsKey(actionName))
                        {
                            frameList = actionMaps[actionName];
                        }
                        else
                        {
                            frameList = new SortedList <string, SpriteSheetFrameData>();
                            actionMaps.Add(actionName, frameList);
                        }

                        string idName = metadata.idName;
                        if (frameList.ContainsKey(idName))
                        {
                            Debug.LogWarning(string.Format("{0}_{1}重复ID:{2}", groupName, actionName, idName));

                            metadata.idName = string.Format("{0}_{1}", metadata.idName, frameList.Count);
                            idName          = metadata.idName;
                        }
                        frameList.Add(idName, metadata);
                    }
                }

                if (saveRootPath == "")
                {
                    saveRootPath = assetRootPath;
                }
                Dictionary <string, Dictionary <string, AnimationClip> > outMap = new Dictionary <string, Dictionary <string, AnimationClip> >();
                foreach (var groupPair in sheetDict)
                {
                    //保存资源
                    string   groupName       = groupPair.Key;
                    string[] subFolders      = groupName.Split(new char[] { '@' });
                    string   saveOutRootPath = saveRootPath;
                    for (int i = 0; i < subFolders.Length; i++)
                    {
                        saveOutRootPath = XPathTools.Combine(saveOutRootPath, subFolders[i]);
                        if (!XFolderTools.Exists(saveOutRootPath))
                        {
                            XFolderTools.CreateDirectory(saveOutRootPath);
                        }
                    }

                    Dictionary <string, AnimationClip> outActionMap;
                    if (outMap.ContainsKey(groupName))
                    {
                        outActionMap = outMap[groupName];
                    }
                    else
                    {
                        outActionMap = new Dictionary <string, AnimationClip>();
                        outMap.Add(groupName, outActionMap);
                    }

                    foreach (var actionPair in groupPair.Value)
                    {
                        //保存动画Clip
                        string outName  = actionPair.Key;
                        string saveName = string.Format("{0}.anim", outName);
                        string savePath = Path.Combine(saveOutRootPath, saveName);

                        List <Sprite> spriteList = new List <Sprite>();
                        foreach (var listPair in actionPair.Value)
                        {
                            spriteList.Add(listPair.Value.sprite);
                        }
                        AnimationClip clip = MakeAnimationClip(spriteList.ToArray(), SpriteToolsConfig.GetInstance().defaultFrameRate, savePath);

                        outActionMap.Add(actionPair.Key, clip);
                        if (callback != null)
                        {
                            callback(clip);
                        }
                    }
                }
                return(outMap);
            }
            return(null);
        }