Пример #1
0
 public void ExcelToTxt()
 {
     string[,] ExcelInfo = ExcelHelper.GetFirstSheetInfo(excelPath);
     for (int j = 1; j < ExcelInfo.GetLength(1); j++)
     {
         string oneLanuage = "";
         for (int i = 1; i < ExcelInfo.GetLength(0); i++)
         {
             if (i != 1)
             {
                 oneLanuage += "\n";
             }
             oneLanuage += ExcelInfo[i, 0] + "=" + ExcelInfo[i, j].Replace("=", "#");
         }
         oneLanuage = oneLanuage.Replace("\n\n", "\n");
         if (!LanuageNameToPath.ContainsKey(ExcelInfo[0, j]))
         {
             AFLogger.EditorErrorLog("请注意Excel表格与LanuageNameToPath的对应!");
             return;
         }
         FileHelper.CreatFile(LanuageNameToPath[ExcelInfo[0, j]],
                              System.Text.Encoding.UTF8.GetBytes(oneLanuage), true);
     }
     AFLogger.d("Excel表格转TXT文件转换完成!");
 }
Пример #2
0
        public void TxtToExcel()
        {
            List <string> LanuageDes  = new List <string>();
            List <string> LanuageName = new List <string>(LanuageNameToPath.Keys);
            Dictionary <string, Dictionary <string, string> > LanuageNameToCon = new Dictionary <string, Dictionary <string, string> >();

            Dictionary <Vector2, string> excelCon = new Dictionary <Vector2, string>();

            excelCon.Add(new Vector2(1, 1), "Description");
            for (int i = 0; i < LanuageName.Count; i++)
            {
                Dictionary <string, string> txtCon = new Dictionary <string, string>();
                TextAsset ta    = AssetDatabase.LoadAssetAtPath <TextAsset>(LanuageNameToPath[LanuageName[i]]);
                string    text  = ta.text;
                string[]  lines = text.Split('\n');
                foreach (string line in lines)
                {
                    if (line == null)
                    {
                        continue;
                    }
                    string[] keyAndValue = line.Split('=');
                    if (keyAndValue.Length < 2)
                    {
                        AFLogger.EditorErrorLog(LanuageName + "语言文件路径为:" + LanuageNameToPath[LanuageName[i]] +
                                                "不符合格式要求,请检查:" + line);
                        continue;
                    }
                    if (i == 0)
                    {
                        LanuageDes.Add(keyAndValue[0]);
                    }
                    if (txtCon.ContainsKey(keyAndValue[0]))
                    {
                        AFLogger.EditorErrorLog("相同的描述:" + keyAndValue[0]);
                        return;
                    }
                    txtCon.Add(keyAndValue[0], keyAndValue[1]);
                }
                LanuageNameToCon.Add(LanuageName[i], txtCon);
                excelCon.Add(new Vector2(1, i + 2), LanuageName[i]);
            }
            for (int j = 0; j < LanuageDes.Count; j++)
            {
                excelCon.Add(new Vector2(j + 2, 1), LanuageDes[j]);
                for (int k = 0; k < LanuageName.Count; k++)
                {
                    excelCon.Add(new Vector2(j + 2, k + 2), LanuageNameToCon[LanuageName[k]][LanuageDes[j]]);
                }
            }
            ExcelHelper.WriteExcel(excelPath, excelCon);
            EditorUtility.RevealInFinder(excelPath);
            AFLogger.d("TXT文件转Excel表格转化完成");
        }
Пример #3
0
 public void UpdateCategoryStr()
 {
     AF_OneAB.CategoryStr.Clear();
     foreach (AF_ABOneClass oneClass in m_AllClass)
     {
         if (oneClass.ABClassType == "")
         {
             AFLogger.EditorErrorLog("m_AllClass.ABClassType不能为空");
             return;
         }
         AF_OneAB.CategoryStr.Add(oneClass.ABClassType);
     }
 }
Пример #4
0
        static void SetABName(string name, string path)
        {
            AssetImporter assetImporter = AssetImporter.GetAtPath(path);

            if (assetImporter == null)
            {
                AFLogger.EditorErrorLog("不存在此路径文件:" + path);
            }
            else
            {
                assetImporter.assetBundleName = name.ToLower();
            }
        }
Пример #5
0
        bool CommonBuildSetting()
        {
            if ((buildPlatform == BuildPlatform.Android && AndroidAPKPath == "") ||
                (buildPlatform == BuildPlatform.IOS && XCodeProjectPath == ""))
            {
                AFLogger.EditorErrorLog("APP目标打包路径不能为空");
                return(false);
            }
            EditorUserBuildSettings.development = DevelopmentBuild;
            PlayerSettings.productName          = DisplayName;
            AF_ABConfig ABConfig = AssetDatabasex.LoadAssetOfType <AF_ABConfig>("AF_ABConfig");

            return(true);
        }
Пример #6
0
        static void BunildAssetBundle(AF_ABConfig abConfig)
        {
            string[] allBundles = AssetDatabase.GetAllAssetBundleNames();
            //key : 为全路径 value :为名字
            Dictionary <string, string> resPathDic = new Dictionary <string, string>();

            for (int i = 0; i < allBundles.Length; i++)
            {
                string[] allBundlePath = AssetDatabase.GetAssetPathsFromAssetBundle(allBundles[i]);
                for (int j = 0; j < allBundlePath.Length; j++)
                {
                    //判断有没有包含脚本文件
                    if (allBundlePath[j].EndsWith(".cs"))
                    {
                        continue;
                    }

                    //Debug.Log("此AB包:" + allBundles[i] + "下面包含的资源文件路径:" + allBundlePath[j]);
                    if (ValidPath(allBundlePath[j]))
                    {
                        resPathDic.Add(allBundlePath[j], allBundles[i]);
                    }
                }
            }

            //现在已经设置好了在这一次要打包的AB包,因此要清除无用的AB包,比如之前存在的AB包
            DeleteAB();
            //生成自己的配置表
            WriteData(resPathDic, abConfig.configWritingMode, abConfig.packageABType);

            AssetBundleManifest manifest = BuildPipeline.BuildAssetBundles(m_BundleTargetPath, BuildAssetBundleOptions.ChunkBasedCompression, buildTarget);

            if (manifest == null)
            {
                AFLogger.EditorErrorLog("AssetBundle" + buildTarget.ToString() + "打包失败,请检查设置!");
            }
            else
            {
                AFLogger.d("AssetBundle" + buildTarget.ToString() + "打包完毕");
            }
        }
Пример #7
0
        public void AutoAddTarget()
        {
            if (TargetDataSetName.IsNullOrEmpty())
            {
                AFLogger.EditorErrorLog("DataSet名称为空!");
                return;
            }
            AF_ABConfig ABConfig = AssetDatabasex.LoadAssetOfType <AF_ABConfig>("AF_ABConfig");

            char[] t       = ABConfig.defaultDataSetPath.ToCharArray();
            string xmlPath = ABConfig.defaultDataSetPath;

            if (t[t.Length - 1] == '/')
            {
                xmlPath += TargetDataSetName + ".xml";
            }
            else
            {
                xmlPath += "/" + TargetDataSetName + ".xml";
            }
            if (xmlPath == "")
            {
                AFLogger.d("未找到DataSet对应的xml文件,请检查m_AllFileAB中是否有配置CategoryOfOwnership为" +
                           ABClassType + "且isHasDataset为true");
                return;
            }
            if (mImagetTargetInfo == null)
            {
                mImagetTargetInfo = new List <OneTargetInfo>();
            }
            List <string> allRecogTarget = AFSDK_DataSetHandle.GetDataSetTarget(xmlPath);

            if (allRecogTarget == null)
            {
                AFLogger.EditorErrorLog("解析xml失败!");
                return;
            }
            for (int j = mImagetTargetInfo.Count - 1; j >= 0; j--)
            {
                bool isNeedRemove = true;
                for (int i = allRecogTarget.Count - 1; i >= 0; i--)
                {
                    if (mImagetTargetInfo[j].ImageTargetName.Equals(allRecogTarget[i]))
                    {
                        isNeedRemove = false;
                        allRecogTarget.RemoveAt(i);
                        break;
                    }
                }
                if (isNeedRemove)
                {
                    mImagetTargetInfo.RemoveAt(j);
                }
            }
            foreach (string recogName in allRecogTarget)
            {
                OneTargetInfo oneTargetInfo = new OneTargetInfo();
                oneTargetInfo.ImageTargetName     = recogName;
                oneTargetInfo.oneResInfo.ResScale = new Vector3(1, 1, 1);
                mImagetTargetInfo.Add(oneTargetInfo);
            }
        }
Пример #8
0
        public static void Build()
        {
            m_BundleTargetPath = EditorAssetPath.ProjectPath + "AssetBundle/" + buildTarget.ToString() + "/";
            AppInfoConfig appInfoConfig = AssetDatabasex.LoadAssetOfType <AppInfoConfig>("AppInfoConfig");
            AF_ABConfig   abConfig      = AssetDatabasex.LoadAssetOfType <AF_ABConfig>("AF_ABConfig");

            EditorAssetPath.InitABBuildPath(abConfig);
            //清空
            m_ConfigFile.Clear();
            m_AllFileAB.Clear();
            m_AllFileDir.Clear();
            m_AllPrefabDir.Clear();
            string mTargetPath = EditorAssetPath.ABTargetPath;
            string mInfoPath   = EditorAssetPath.ABInfoPath;

            if (abConfig.packageABType != PackageABType.PhoneAB)
            {
                mTargetPath = EditorAssetPath.ABTargetPath + buildTarget.ToString() + "/";
                mInfoPath   = EditorAssetPath.ABInfoPath + buildTarget.ToString() + "/";
            }

            if (Directory.Exists(mTargetPath))
            {
                FileUtil.DeleteFileOrDirectory(mTargetPath);
            }
            if (Directory.Exists(mInfoPath))
            {
                FileUtil.DeleteFileOrDirectory(mInfoPath);
            }
            Directory.CreateDirectory(mInfoPath);
            Directory.CreateDirectory(mTargetPath);
            Directory.CreateDirectory(m_BundleTargetPath);
            //创建APP版本文件
            FileHelper.CreatFile(EditorAssetPath.AppInfoPath, SerializeHelper.ToByteArray(appInfoConfig), true);
            Dictionary <string, bool> ClassToNeedPackageAB = new Dictionary <string, bool>();

            for (int i = 0; i < abConfig.m_AllClass.Count; i++)
            {
                if (abConfig.m_AllClass[i].isSameAppType(abConfig.CurrentAppType))
                {
                    ClassToNeedPackageAB.Add(abConfig.m_AllClass[i].ABClassType, abConfig.m_AllClass[i].isNeedPackageAB);
                }
            }
            //剔除重复路径,将单个文件及文件夹的路径保存下来
            //先处理文件夹再处理单个文件,因为有可能prefab依赖某个文件中的东西,所以要进行过滤
            foreach (AF_OneAB oneAB in abConfig.m_AllFileAB)
            {
                bool isNeedPackageAB = false;
                for (int k = 0; k < oneAB.CategoryOfOwnership.Count; k++)
                {
                    if (ClassToNeedPackageAB.ContainsKey(oneAB.CategoryOfOwnership[k]) &&
                        ClassToNeedPackageAB[oneAB.CategoryOfOwnership[k]])
                    {
                        isNeedPackageAB = true;
                        break;
                    }
                }
                if (!isNeedPackageAB)
                {
                    continue;
                }
                if (m_AllFileDir.ContainsKey(oneAB.mABIdentifier))
                {
                    AFLogger.EditorErrorLog("AB包配置名字重复,请检查!");
                    EditorUtility.ClearProgressBar();
                }
                else
                {
                    m_AllFileDir.Add(oneAB.mABIdentifier, oneAB.Path);
                    //保存已打包的AB包路径
                    m_AllFileAB.Add(oneAB.Path);
                    m_ConfigFile.Add(oneAB.Path);
                }
            }
            string[] AllPrefabsPath = abConfig.GetAllPrefabsPath();
            if (AllPrefabsPath.Length > 0)
            {
                //获取路径下的所有prefab
                string[] allStr = AssetDatabase.FindAssets("t:Prefab", AllPrefabsPath);
                AFLogger.EditorInfoLog("获取的路径长度:" + allStr.Length);
                for (int i = 0; i < allStr.Length; i++)
                {
                    bool isNeedPackageAB = false;
                    for (int k = 0; k < abConfig.m_AllPrefabAB[i].CategoryOfOwnership.Count; k++)
                    {
                        if (ClassToNeedPackageAB.ContainsKey(abConfig.m_AllPrefabAB[i].CategoryOfOwnership[k]) &&
                            ClassToNeedPackageAB[abConfig.m_AllPrefabAB[i].CategoryOfOwnership[k]])
                        {
                            isNeedPackageAB = true;
                            break;
                        }
                    }
                    if (!isNeedPackageAB)
                    {
                        continue;
                    }
                    //GUID转asset路径
                    string path = AssetDatabase.GUIDToAssetPath(allStr[i]);
                    EditorUtility.DisplayProgressBar("查找Prefab", "Prefab:" + path, i * 1.0f / allStr.Length);
                    m_ConfigFile.Add(path);
                    if (!ContainAllFileAB(path))
                    {
                        //获取资源的所有依赖
                        string[]      allDepend     = AssetDatabase.GetDependencies(path);
                        List <string> allDependPath = new List <string>();
                        //遍历依赖文件
                        for (int j = 0; j < allDepend.Length; j++)
                        {
                            if (!ContainAllFileAB(allDepend[j]) && !allDepend[j].EndsWith(".cs", System.StringComparison.Ordinal))
                            {
                                m_AllFileAB.Add(allDepend[j]);
                                allDependPath.Add(allDepend[j]);
                            }
                        }
                        if (m_AllPrefabDir.ContainsKey(abConfig.m_AllPrefabAB[i].mABIdentifier))
                        {
                            AFLogger.EditorErrorLog("存在相同名字的Prefab!名字:" + abConfig.m_AllPrefabAB[i].mABIdentifier);
                            EditorUtility.ClearProgressBar();
                        }
                        else
                        {
                            m_AllPrefabDir.Add(abConfig.m_AllPrefabAB[i].mABIdentifier, allDependPath);
                        }
                    }
                }
            }
            //点击打包之后可以看见更改的文件的.meta文件改变
            //文件夹设置ABName
            foreach (string name in m_AllFileDir.Keys)
            {
                SetABName(name, m_AllFileDir[name]);
            }
            //单个文件设置包名
            foreach (string name in m_AllPrefabDir.Keys)
            {
                SetABName(name, m_AllPrefabDir[name]);
            }

            //打包
            BunildAssetBundle(abConfig);

            //清除AB包名,因为上面更改了.meta文件,我们很多时候会使用svn或者git,有可能会导致一不小心上传特别乱
            string[] oldABNames = AssetDatabase.GetAllAssetBundleNames();
            for (int i = 0; i < oldABNames.Length; i++)
            {
                AssetDatabase.RemoveAssetBundleName(oldABNames[i], true);
                EditorUtility.DisplayProgressBar("清除AB包名", "名字:" + oldABNames[i], i * 1.0f / oldABNames.Length);
            }

            EditorUtility.ClearProgressBar();
            //根据设置生成文件
            ABBuildFinishEvent.BundleFinish(mTargetPath, m_BundleTargetPath, abConfig, mInfoPath, appInfoConfig);
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
            EditorUtility.ClearProgressBar();
        }
Пример #9
0
        /// <summary>
        /// AB包打包完成后执行的函数,这里是将AB包移到指定的路径并生成对应的info文件
        /// </summary>
        /// <param name="mTargetPath">AB包目标路径,可以在ABCommonPath脚本中设置</param>
        /// <param name="m_BunleTargetPath">AB包初步路径</param>
        /// <param name="abConfig"></param>
        /// <param name="mInfoPath">info信息文件路径</param>
        /// <param name="AppInfoConfig"></param>
        public static void BundleFinish(string mTargetPath, string m_BunleTargetPath, AF_ABConfig abConfig, string mInfoPath, AppInfoConfig AppInfoConfig)
        {
            //一个类别对应的info
            Dictionary <string, OneABClassInfo> ClassToInfo    = new Dictionary <string, OneABClassInfo>();
            Dictionary <string, bool>           ClassToAppType = new Dictionary <string, bool>();
            Dictionary <string, string>         ABNameToPath   = new Dictionary <string, string>();

            for (int i = 0; i < abConfig.m_AllClass.Count; i++)
            {
                string classStr = abConfig.m_AllClass[i].ABClassType;
                ClassToAppType.Add(classStr, abConfig.m_AllClass[i].isSameAppType(abConfig.CurrentAppType));
                OneABClassInfo oneClassInfo = new OneABClassInfo();
                oneClassInfo.RecogType = abConfig.m_AllClass[i].ARrecogType;
                switch (oneClassInfo.RecogType)
                {
                case ARRecogType.DataSet:
                    List <OneDataSetInfo> dataSetInfos = new List <OneDataSetInfo>();
                    foreach (OneDataSet oneDataSet in abConfig.m_AllClass[i].dataSetList)
                    {
                        OneDataSetInfo oneDataSetInfo = new OneDataSetInfo();
                        oneDataSetInfo.TargetDataSet = oneDataSet.TargetDataSetName;
                        //记录识别图资料
                        oneDataSetInfo.TargetInfo = new Dictionary <string, OneTargetInfo>();
                        char[] t           = abConfig.defaultDataSetPath.ToCharArray();
                        string dataSetPath = abConfig.defaultDataSetPath;
                        if (t[t.Length - 1] != '/')
                        {
                            dataSetPath += "/";
                        }
                        string targetDataSetName = oneDataSet.TargetDataSetName;
                        string xmlMD5            = "";
                        string datMD5            = "";
                        if (abConfig.packageABType == PackageABType.StreamingAssetAB)
                        {
                            string vuforiaPath = Application.streamingAssetsPath + "/Vuforia/";
                            Directory.CreateDirectory(vuforiaPath);
                            //拷贝识别资源
                            if (!FileHelper.CopyFile(dataSetPath +
                                                     targetDataSetName
                                                     + ".xml", vuforiaPath + targetDataSetName + ".xml"))
                            {
                                break;
                            }
                            xmlMD5 = FileHelper.getFileHash(vuforiaPath + targetDataSetName + ".dat");
                            if (!FileHelper.CopyFile(dataSetPath +
                                                     targetDataSetName
                                                     + ".dat", vuforiaPath + targetDataSetName + ".dat"))
                            {
                                break;
                            }
                            datMD5 = FileHelper.getFileHash(vuforiaPath + targetDataSetName + ".xml");

                            if (!oneClassInfo.ABName.ContainsKey(targetDataSetName + ".xml") &&
                                !oneClassInfo.ABName.ContainsKey(targetDataSetName + ".dat"))
                            {
                                //将识别资源添加到ABName中,因为也是要下载的,同时记录其大小
                                oneClassInfo.ABName.Add(targetDataSetName + ".xml",
                                                        FileHelper.GetFileSize(vuforiaPath + targetDataSetName + ".xml"));
                                oneClassInfo.ABName.Add(targetDataSetName + ".dat",
                                                        FileHelper.GetFileSize(vuforiaPath + targetDataSetName + ".dat"));
                            }
                        }
                        else
                        {
                            //拷贝识别资源
                            if (!FileHelper.CopyFile(dataSetPath +
                                                     targetDataSetName
                                                     + ".xml", mTargetPath + targetDataSetName + ".xml"))
                            {
                                break;
                            }
                            xmlMD5 = FileHelper.getFileHash(dataSetPath +
                                                            targetDataSetName
                                                            + ".xml");

                            if (!FileHelper.CopyFile(dataSetPath
                                                     + targetDataSetName + ".dat",
                                                     mTargetPath + targetDataSetName + ".dat"))
                            {
                                break;
                            }
                            datMD5 = FileHelper.getFileHash(dataSetPath +
                                                            targetDataSetName + ".dat");

                            if (!oneClassInfo.ABName.ContainsKey(targetDataSetName + ".xml") &&
                                !oneClassInfo.ABName.ContainsKey(targetDataSetName + ".dat"))
                            {
                                //将识别资源添加到ABName中,因为也是要下载的,同时记录其大小
                                oneClassInfo.ABName.Add(targetDataSetName + ".xml",
                                                        FileHelper.GetFileSize(mTargetPath + targetDataSetName + ".xml"));
                                oneClassInfo.ABName.Add(targetDataSetName + ".dat",
                                                        FileHelper.GetFileSize(mTargetPath + targetDataSetName + ".dat"));
                            }
                        }

                        //添加识别资源的MD5码,
                        if (!oneClassInfo.FileMD5.ContainsKey(targetDataSetName + ".xml") &&
                            !oneClassInfo.FileMD5.ContainsKey(targetDataSetName + ".dat"))
                        {
                            // Debug.Log("第一次添加xml MD5:" + CategoryOfOwnershipS + " " + targetDataSetName);
                            oneClassInfo.FileMD5.Add(targetDataSetName + ".xml", xmlMD5);
                            oneClassInfo.FileMD5.Add(targetDataSetName + ".dat", datMD5);
                        }
                        else
                        {
                            //是已经打包过的类别
                            // Debug.Log("重复添加xml MD5:" + CategoryOfOwnershipS + " " + targetDataSetName);
                        }
                        if (!ABNameToPath.ContainsKey(targetDataSetName + ".xml") &&
                            !ABNameToPath.ContainsKey(targetDataSetName + ".dat"))
                        {
                            ABNameToPath.Add(targetDataSetName + ".xml", classStr + "/" + targetDataSetName + ".xml");
                            ABNameToPath.Add(targetDataSetName + ".dat", classStr + "/" + targetDataSetName + ".dat");
                        }


                        for (int j = 0; j < oneDataSet.mImagetTargetInfo.Count; j++)
                        {
                            oneDataSetInfo.TargetInfo.Add(oneDataSet.mImagetTargetInfo[j].ImageTargetName, oneDataSet.mImagetTargetInfo[j]);
                        }
                        dataSetInfos.Add(oneDataSetInfo);
                    }
                    oneClassInfo.dataSetInfos = dataSetInfos;
                    break;

                case ARRecogType.Plane:
                    oneClassInfo.ResInfoForPlane = abConfig.m_AllClass[i].ResInfoForPlane;
                    break;
                }
                oneClassInfo.isNeedPackageAB = abConfig.m_AllClass[i].isNeedPackageAB;
                ClassToInfo.Add(classStr, oneClassInfo);
            }
            List <AF_OneAB> allAB = new List <AF_OneAB>();

            foreach (AF_OneAB oneAB in abConfig.m_AllFileAB)
            {
                allAB.Add(oneAB);
            }
            foreach (AF_OneAB oneAB in abConfig.m_AllPrefabAB)
            {
                allAB.Add(oneAB);
            }
            //遍历
            for (int i = 0; i < allAB.Count; i++)
            {
                EditorUtility.DisplayProgressBar("整理AB包资源", "名字TargetDataSet:" + allAB[i].mABIdentifier, i * 1.0f / (allAB.Count + abConfig.m_AllPrefabAB.Count));
                //分别拷贝到对应的类别中
                for (int k = 0; k < allAB[i].CategoryOfOwnership.Count; k++)
                {
                    string CategoryOfOwnershipS = allAB[i].CategoryOfOwnership[k];
                    if (!ClassToInfo.ContainsKey(CategoryOfOwnershipS))
                    {
                        AFLogger.EditorErrorLog(allAB[i].mABIdentifier + "所属类型错误,不在m_AllClass内,请检查");
                        EditorUtility.ClearProgressBar();
                        return;
                    }
                    //不是当前APP Type的类型,跳过
                    if (!ClassToAppType[CategoryOfOwnershipS])
                    {
                        continue;
                    }
                    if (!ClassToInfo[CategoryOfOwnershipS].isNeedPackageAB)
                    {
                        continue;
                    }
                    string ABIdentifier = allAB[i].mABIdentifier.ToLower();

                    //拷贝AB包
                    if (!FileHelper.CopyFile(m_BunleTargetPath + "/" + ABIdentifier,
                                             mTargetPath + ABIdentifier))
                    {
                        break;
                    }
                    //添加AB包的MD5码
                    string ABMD5 = FileHelper.getFileHash(m_BunleTargetPath + "/" + ABIdentifier);
                    if (!ClassToInfo[CategoryOfOwnershipS].FileMD5.ContainsKey(ABIdentifier))
                    {
                        ClassToInfo[CategoryOfOwnershipS].FileMD5.Add(ABIdentifier, ABMD5);
                    }
                    //是已经打包过的类别
                    if (ABNameToPath.ContainsKey(ABIdentifier))
                    {
                        ABNameToPath.Add(ABIdentifier, CategoryOfOwnershipS + "/" + ABIdentifier);
                    }
                    //保存文件的大小
                    ClassToInfo[CategoryOfOwnershipS].ABName.Add(ABIdentifier,
                                                                 FileHelper.GetFileSize(mTargetPath + ABIdentifier));
                }
            }
            //保存info文件
            for (int i = 0; i < abConfig.m_AllClass.Count; i++)
            {
                if (abConfig.m_AllClass[i].isNeedPackageAB)
                {
                    SerializeHelper.SaveJson <OneABClassInfo>(ClassToInfo[abConfig.m_AllClass[i].ABClassType.ToString()],
                                                              mInfoPath + abConfig.m_AllClass[i].ABClassType + "Info.txt");
                }
            }
            if (abConfig.configWritingMode == ConfigWritingMode.Binary)
            {
                FileHelper.DeleteFile(PathTool.ProjectPath + "Assets/AssetbundleConfig.bytes");
                FileHelper.CopyFile(m_BunleTargetPath + "assetbundleconfig", mTargetPath + "AssetbundleConfig");
            }
            AssetDatabase.Refresh();
            Debug.Log("资源拷贝完毕,保存路径为 : " + mTargetPath);
            EditorUtility.RevealInFinder(mTargetPath);
        }