Exemple #1
0
    public override IEnumerator Execute(UTContext context)
    {
        var theOutputFile = outputFileName.EvaluateIn(context);

        if (string.IsNullOrEmpty(theOutputFile))
        {
            throw new UTFailBuildException("You must specify an output file name.", this);
        }

        var theBundleType = bundleType.EvaluateIn(context);

        var theFiles = new string[0];

        if (theBundleType == UTTypeOfBundle.SimpleAssetBundle || !useScenesFromBuildSettings.EvaluateIn(context))
        {
            var theIncludes = EvaluateAll(includes, context);
            var theExcludes = EvaluateAll(excludes, context);
            theFiles = UTFileUtils.CalculateFileset(theIncludes, theExcludes);

            UTFileUtils.FullPathToProjectPath(theFiles);
        }
        else
        {
            var scenes = EditorBuildSettings.scenes;
            theFiles = Array.ConvertAll <EditorBuildSettingsScene, string> (scenes, scene => scene.path);
        }

        if (UTPreferences.DebugMode)
        {
            foreach (var file in theFiles)
            {
                Debug.Log("Including: " + file, this);
            }
        }
        Debug.Log("Including " + theFiles.Length + " assets/scenes.");

        if (theBundleType == UTTypeOfBundle.StreamedScenes && theFiles.Length == 0)
        {
            throw new UTFailBuildException("No scenes have been selected. Unable to build a streamed scenes asset bundle with no scenes.", this);
        }

        var     theMainAsset  = "";
        UObject realMainAsset = null;

        UObject[] realAssets = null;

        if (theBundleType == UTTypeOfBundle.SimpleAssetBundle)
        {
            theMainAsset = mainAsset.EvaluateIn(context);
            if (!String.IsNullOrEmpty(theMainAsset))
            {
                if (theMainAsset.Contains("*"))
                {
                    var finalList = UTFileUtils.CalculateFileset(new string[] { theMainAsset }, new string[0]);
                    if (finalList.Length != 1)
                    {
                        throw new UTFailBuildException("Main asset wildcard " + theMainAsset + " yielded " +
                                                       finalList.Length + " results but should yield exactly one asset.", this);
                    }
                    theMainAsset = UTFileUtils.FullPathToProjectPath(finalList [0]);
                }

                // now get the real objects for the paths
                realMainAsset = AssetDatabase.LoadMainAssetAtPath(theMainAsset);

                if (realMainAsset == null)
                {
                    throw new UTFailBuildException("Unable to load the main asset " + theMainAsset + " from asset database.", this);
                }
            }

            realAssets = Array.ConvertAll <string, UObject> (theFiles, file => {
                var result = AssetDatabase.LoadMainAssetAtPath(file);
                if (result == null)
                {
                    throw new UTFailBuildException("Unable to load the asset " + file, this);
                }
                return(result);
            });
        }


        var theBuildTarget = targetPlatform.EvaluateIn(context);

        if (pushDependencies.EvaluateIn(context))
        {
            UTAssetDependencyStack.Push();
        }

        try {
            UTFileUtils.EnsureParentFolderExists(theOutputFile);
            if (theBundleType == UTTypeOfBundle.StreamedScenes)
            {
                Debug.Log("Building streamed scenes asset bundle.");
                var result = BuildPipeline.BuildStreamedSceneAssetBundle(theFiles, theOutputFile, theBuildTarget);
                if (!string.IsNullOrEmpty(result))
                {
                    throw new UTFailBuildException("Building streamed scene asset bundle failed. " + result, this);
                }
            }
            else
            {
                Debug.Log("Building asset bundle.");
                var realCollectDependencies      = collectDependencies.EvaluateIn(context);
                var realCompleteAssets           = completeAssets.EvaluateIn(context);
                var realDisableWriteTypeTree     = disableWriteTypeTree.EvaluateIn(context);
                var realDeterministicAssetBundle = deterministicAssetBundle.EvaluateIn(context);


                var buildOpts = (BuildAssetBundleOptions)0;

                if (realCollectDependencies)
                {
                    buildOpts |= BuildAssetBundleOptions.CollectDependencies;
                }

                if (realCompleteAssets)
                {
                    buildOpts |= BuildAssetBundleOptions.CompleteAssets;
                }

                if (realDisableWriteTypeTree)
                {
                    buildOpts |= BuildAssetBundleOptions.DisableWriteTypeTree;
                }

                if (realDeterministicAssetBundle)
                {
                    buildOpts |= BuildAssetBundleOptions.DeterministicAssetBundle;
                }

                if (!BuildPipeline.BuildAssetBundle(realMainAsset, realAssets, theOutputFile, buildOpts, theBuildTarget))
                {
                    throw new UTFailBuildException("Building asset bundle failed.", this);
                }
            }
            Debug.Log("Built asset bundle at " + theOutputFile);
        } finally {
            if (popAllDependencies.EvaluateIn(context))
            {
                UTAssetDependencyStack.PopAll();
            }
            else if (popDependencies.EvaluateIn(context))
            {
                UTAssetDependencyStack.Pop();
            }
        }
        yield return("");
    }
    public override IEnumerator Execute(UTContext context)
    {
        var theOutput = outputFileName.EvaluateIn(context);

        if (string.IsNullOrEmpty(theOutput))
        {
            throw new UTFailBuildException("You must specify an output file name.", this);
        }

        if (theOutput.StartsWith(Application.dataPath))
        {
            throw new UTFailBuildException("Building a player inside the assets folder will break the build. Please place it somewhere else.", this);
        }


        var theTarget = targetPlatform.EvaluateIn(context);

        if (addPlatformExtension.EvaluateIn(context))
        {
            theOutput += GetPlatformExtension(theTarget);
            UTFileUtils.EnsureParentFolderExists(theOutput);
        }

#if UNITY_4_1
        // workaround for UNITY_4_1 offering StandaloneOSXUniversal but not being able to build for it.
        if (theTarget == BuildTarget.StandaloneOSXUniversal)
        {
            theTarget = BuildTarget.StandaloneOSXIntel;
        }
#endif

        var useBuildSettings = useScenesFromBuildSettings.EvaluateIn(context);

        string[] scenes;
        if (!useBuildSettings)
        {
            // get them from includes/excludes
            var theIncludes = EvaluateAll(includes, context);
            var theExcludes = EvaluateAll(excludes, context);

            var fileSet = UTFileUtils.CalculateFileset(theIncludes, theExcludes);
            if (fileSet.Length == 0)
            {
                throw new UTFailBuildException("The file set yielded no scenes to include into the player.", this);
            }

            scenes = fileSet;
        }
        else
        {
            var scenesFromEditor = EditorBuildSettings.scenes;
            if (scenesFromEditor.Length == 0)
            {
                throw new UTFailBuildException("There are no scenes set up in the editor build settings.", this);
            }
            var active = Array.FindAll(scenesFromEditor, scene => scene.enabled);
            scenes = Array.ConvertAll(active, scene => scene.path);
        }

        if (UTPreferences.DebugMode)
        {
            foreach (var entry in scenes)
            {
                Debug.Log("Adding scene: " + entry, this);
            }
        }

        BuildOptions buildOptions = BuildOptions.None;
        if (developmentBuild.EvaluateIn(context))
        {
            buildOptions |= BuildOptions.Development;
        }

        if (runTheBuiltPlayer.EvaluateIn(context))
        {
            buildOptions |= BuildOptions.AutoRunPlayer;
        }

        if (showTheBuiltPlayer.EvaluateIn(context))
        {
            buildOptions |= BuildOptions.ShowBuiltPlayer;
        }

        if (buildStreamedScenes.EvaluateIn(context))
        {
            buildOptions |= BuildOptions.BuildAdditionalStreamedScenes;
        }

        if (acceptExternalModifications.EvaluateIn(context))
        {
            buildOptions |= BuildOptions.AcceptExternalModificationsToPlayer;
        }

        if (connectWithProfiler.EvaluateIn(context))
        {
            buildOptions |= BuildOptions.ConnectWithProfiler;
        }

        if (allowDebugging.EvaluateIn(context))
        {
            buildOptions |= BuildOptions.AllowDebugging;
        }

        if (uncompressedAssetBundle.EvaluateIn(context))
        {
            buildOptions |= BuildOptions.UncompressedAssetBundle;
        }

        if (theTarget == BuildTarget.WebPlayer || theTarget == BuildTarget.WebPlayerStreamed)
        {
            if (offlineDeployment.EvaluateIn(context))
            {
                buildOptions |= BuildOptions.WebPlayerOfflineDeployment;
            }
            if (deployOnline.EvaluateIn(context))
            {
                //buildOptions |= BuildOptions.DeployOnline;
            }
        }

        if (theTarget == BuildTarget.iOS)
        {
            if (symlinkLibraries.EvaluateIn(context))
            {
                buildOptions |= BuildOptions.SymlinkLibraries;
            }
        }


        Debug.Log("Building " + ObjectNames.NicifyVariableName(theTarget.ToString()) + " player including " + scenes.Length + " scenes to " + theOutput);
        yield return("");

        if (pushDependencies.EvaluateIn(context))
        {
            UTAssetDependencyStack.Push();
        }
        try {
            // build the player.
            var result = BuildPipeline.BuildPlayer(scenes, theOutput, theTarget, buildOptions);
            if (!string.IsNullOrEmpty(result))
            {
                throw new UTFailBuildException("Building the player failed. " + result, this);
            }
        }
        finally {
            if (popAllDependencies.EvaluateIn(context))
            {
                UTAssetDependencyStack.PopAll();
            }
            else if (popDependencies.EvaluateIn(context))
            {
                UTAssetDependencyStack.Pop();
            }
        }
    }