Beispiel #1
0
        private void ExecuteSetAssetBundleName()
        {
            AssetBundleBuilder builder     = new AssetBundleBuilder();
            ABBuildInfo        abBuildInfo = new ABBuildInfo();

            abBuildInfo.buildFolderList = m_UserData.m_BuildFolderList;
            builder.SetAssetBundleNames(abBuildInfo);
            AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
        }
Beispiel #2
0
        private void ExecuteBuild()
        {
            if (AssetBundleModel.Model.DataSource.CanSpecifyBuildOutputDirectory)
            {
                if (string.IsNullOrEmpty(m_UserData.m_OutputPath))
                {
                    BrowseForFolder();
                }

                if (string.IsNullOrEmpty(m_UserData.m_OutputPath)) //in case they hit "cancel" on the open browser
                {
                    Debug.LogError("AssetBundle Build: No valid output path for build.");
                    return;
                }

                if (m_ForceRebuild.state)
                {
                    string message = "Do you want to delete all files in the directory " + m_UserData.m_OutputPath;
                    if (m_CopyToStreaming.state)
                    {
                        message += " and " + m_streamingPath;
                    }
                    message += "?";
                    if (EditorUtility.DisplayDialog("File delete confirmation", message, "Yes", "No"))
                    {
                        try
                        {
                            if (Directory.Exists(m_UserData.m_OutputPath))
                            {
                                DeleteFilesAndFoldersRecursively(m_UserData.m_OutputPath);
                            }

                            if (m_CopyToStreaming.state)
                            {
                                if (Directory.Exists(m_streamingPath))
                                {
                                    DeleteFilesAndFoldersRecursively(m_streamingPath);
                                }
                            }
                        }
                        catch (System.Exception e)
                        {
                            Debug.LogException(e);
                        }
                    }
                }
                if (!Directory.Exists(m_UserData.m_OutputPath))
                {
                    Directory.CreateDirectory(m_UserData.m_OutputPath);
                }
            }

            BuildAssetBundleOptions opt = BuildAssetBundleOptions.None;

            if (AssetBundleModel.Model.DataSource.CanSpecifyBuildOptions)
            {
                if (m_UserData.m_Compression == CompressOptions.Uncompressed)
                {
                    opt |= BuildAssetBundleOptions.UncompressedAssetBundle;
                }
                else if (m_UserData.m_Compression == CompressOptions.ChunkBasedCompression)
                {
                    opt |= BuildAssetBundleOptions.ChunkBasedCompression;
                }
                foreach (var tog in m_ToggleData)
                {
                    if (tog.state)
                    {
                        opt |= tog.option;
                    }
                }
            }

            ABBuildInfo buildInfo = new ABBuildInfo();

            buildInfo.outputDirectory = m_UserData.m_OutputPath;
            buildInfo.options         = opt;
            buildInfo.buildTarget     = (BuildTarget)m_UserData.m_BuildTarget;
            buildInfo.buildFolderList = m_UserData.m_BuildFolderList;
            buildInfo.isEncrypt       = m_Encrypt.state;
            buildInfo.mergeOneFile    = m_Merge.state;
            buildInfo.onBuild         = (assetBundleName) =>
            {
                if (m_InspectTab == null)
                {
                    return;
                }
                m_InspectTab.AddBundleFolder(buildInfo.outputDirectory);
                m_InspectTab.RefreshBundles();
            };

            AssetBundleBuilder builder = new AssetBundleBuilder();

            builder.BuildAssetBundle(buildInfo);

            AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);

            if (m_CopyToStreaming.state)
            {
                DirectoryCopy(m_UserData.m_OutputPath, m_streamingPath);
            }
        }