public static void WriteBuildData(BundleBuildData buildData)
        {
            if (buildData == null)
            {
                return;
            }
            string configPath = GetBundleBuildDataFilePath();
            string dir        = Path.GetDirectoryName(configPath);

            if (!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }
            JSONWriter.WriteToFile(buildData, configPath);
        }
        public static BundleBuildData ReadBuildData()
        {
            BundleBuildData bundlePackConfig = null;

            string configPath = GetBundleBuildDataFilePath();

            if (File.Exists(configPath))
            {
                bundlePackConfig = JSONReader.ReadFromFile <BundleBuildData>(configPath);
            }

            if (bundlePackConfig == null)
            {
                bundlePackConfig = new BundleBuildData();
            }
            return(bundlePackConfig);
        }
Exemple #3
0
        private void DrawPackOperation()
        {
            if (bundleBuildConfig == null)
            {
                bundleBuildConfig = AssetPackerUtil.ReadBuildData();
            }

            EditorGUILayout.BeginVertical(EditorStyles.helpBox, GUILayout.ExpandHeight(true), GUILayout.ExpandWidth(true));
            {
                EditorGUILayout.LabelField(Contents.BuildTitleContent, EGUIStyles.MiddleCenterLabel);
                EditorGUI.BeginChangeCheck();
                {
                    EGUI.BeginLabelWidth(120);
                    {
                        bundleBuildConfig.OutputDir          = EGUILayout.DrawDiskFolderSelection(Contents.BuildOutputDirStr, bundleBuildConfig.OutputDir);
                        bundleBuildConfig.CleanupBeforeBuild = EditorGUILayout.Toggle(Contents.BuildCleanup, bundleBuildConfig.CleanupBeforeBuild);
                        bundleBuildConfig.PathFormat         = (BundlePathFormatType)EditorGUILayout.EnumPopup(Contents.BuildPathFormatContent, bundleBuildConfig.PathFormat);
                        EditorGUILayout.Space();
                        bundleBuildConfig.IsForceRebuild = EditorGUILayout.Toggle(Contents.ForceRebuild, bundleBuildConfig.IsForceRebuild);
                        bundleBuildConfig.Target         = (ValidBuildTarget)EditorGUILayout.EnumPopup(Contents.BuildTargetContent, bundleBuildConfig.Target);
                        bundleBuildConfig.Compression    = (CompressOption)EditorGUILayout.EnumPopup(Contents.BuildCompressionContent, bundleBuildConfig.Compression);
                    }
                    EGUI.EndLableWidth();
                }
                if (EditorGUI.EndChangeCheck())
                {
                    AssetPackerUtil.WriteBuildData(bundleBuildConfig);
                }

                GUILayout.FlexibleSpace();

                EGUI.BeginGUIBackgroundColor(Color.red);
                {
                    if (GUILayout.Button(Contents.OperationAutoBuildContent, GUILayout.Height(80), GUILayout.ExpandWidth(true)))
                    {
                        EditorApplication.delayCall += () =>
                        {
                            AssetPackerUtil.BuildAssetBundles(packerData, bundleBuildConfig);
                        };
                    }
                }
                EGUI.EndGUIBackgroundColor();
            }
            EditorGUILayout.EndVertical();
        }
        public static void BuildAssetBundles(PackerData packerData, BundleBuildData buildData)
        {
            string outputDir = buildData.OutputDir;

            if (string.IsNullOrEmpty(outputDir))
            {
                Debug.LogError("The outputDir is empty");
                return;
            }
            if (Directory.Exists(outputDir) && buildData.CleanupBeforeBuild)
            {
                Directory.Delete(outputDir, true);
            }

            if (!Directory.Exists(outputDir))
            {
                Directory.CreateDirectory(outputDir);
            }

            var manifest = PackAssetBundle(packerData, buildData, outputDir);

            if (manifest == null)
            {
                Debug.LogError("PackAssetBundle Failed");
                return;
            }

            var    assetDetailConfig         = CreateAssetDetailConfig(packerData);
            string assetDetailConfigFilePath = $"{outputDir}/{AssetConst.GetAssetDetailConfigFileName()}";

            JSONWriter.WriteToFile <AssetDetailConfig>(assetDetailConfig, assetDetailConfigFilePath);

            var    bundleDetailConfig         = CreateBundleDetailConfig(manifest);
            string bundleDetailConfigFilePath = $"{outputDir}/{AssetConst.GetBundleDetailConfigFileName()}";

            JSONWriter.WriteToFile <BundleDetailConfig>(bundleDetailConfig, bundleDetailConfigFilePath);
        }
        private static CompatibilityAssetBundleManifest PackAssetBundle(PackerData packerData, BundleBuildData buildData, string outputDir)
        {
            List <AssetBundleBuild> bundleBuilds = new List <AssetBundleBuild>();

            foreach (var group in packerData.groupDatas)
            {
                foreach (var bundle in group.bundleDatas)
                {
                    AssetBundleBuild build = new AssetBundleBuild();
                    build.assetBundleName = bundle.Path;
                    build.assetNames      = (from asset in bundle.assetDatas select asset.Path).ToArray();
                    bundleBuilds.Add(build);
                }
            }
            var manifest = CompatibilityBuildPipeline.BuildAssetBundles(outputDir, bundleBuilds.ToArray(), buildData.GetBundleOptions(), buildData.GetBuildTarget());

            return(manifest);
        }