Example #1
0
        public static ConfigGraph CreateNewGraphFromImport(string pathToSave)
        {
            // try load from v1.
            try {
                V1.SaveData v1       = V1.SaveData.Data;
                ConfigGraph newGraph = CreateNewGraph(pathToSave);
                newGraph.Import(v1);

                return(newGraph);
            } catch (Exception e) {
                LogUtility.Logger.LogError(LogUtility.kTag, "Failed to import graph from previous version." + e);
            }

            return(null);
        }
Example #2
0
        private void Import(V1.SaveData v1)
        {
            m_lastModified = GetFileTimeUtcString();
            m_version      = ABG_FILE_VERSION;

            foreach (var n in v1.Nodes)
            {
                m_allNodes.Add(new NodeData(n));
            }

            foreach (var c in v1.Connections)
            {
                m_allConnections.Add(new ConnectionData(c));
            }

            EditorUtility.SetDirty(this);
        }
        public static INodeOperation CreateOperation(SaveData saveData, NodeData currentNodeData, Action <NodeException> errorHandler)
        {
            INodeOperation executor = null;

            try {
                switch (currentNodeData.Kind)
                {
                case NodeKind.LOADER_GUI: {
                    executor = new IntegratedGUILoader();
                    break;
                }

                case NodeKind.FILTER_GUI: {
                    // Filter requires multiple output connections
                    var connectionsToChild = saveData.Connections.FindAll(c => c.FromNodeId == currentNodeData.Id);
                    executor = new IntegratedGUIFilter(connectionsToChild);
                    break;
                }

                case NodeKind.IMPORTSETTING_GUI: {
                    executor = new IntegratedGUIImportSetting();
                    break;
                }

                case NodeKind.MODIFIER_GUI: {
                    executor = new IntegratedGUIModifier();
                    break;
                }

                case NodeKind.GROUPING_GUI: {
                    executor = new IntegratedGUIGrouping();
                    break;
                }

                case NodeKind.PREFABBUILDER_GUI: {
                    executor = new IntegratedPrefabBuilder();
                    break;
                }

                case NodeKind.BUNDLECONFIG_GUI: {
                    executor = new IntegratedGUIBundleConfigurator();
                    break;
                }

                case NodeKind.BUNDLEBUILDER_GUI: {
                    executor = new IntegratedGUIBundleBuilder();
                    break;
                }

                case NodeKind.EXPORTER_GUI: {
                    executor = new IntegratedGUIExporter();
                    break;
                }

                default: {
                    Debug.LogError(currentNodeData.Name + " is defined as unknown kind of node. value:" + currentNodeData.Kind);
                    break;
                }
                }
            } catch (NodeException e) {
                errorHandler(e);
            }

            return(executor);
        }
        /**
         *      Perform Run or Setup from parent of given terminal node recursively.
         */
        private static void DoNodeOperation(
            BuildTarget target,
            NodeData currentNodeData,
            ConnectionPointData currentInputPoint,
            ConnectionData connectionToOutput,
            SaveData saveData,
            Dictionary <ConnectionData, Dictionary <string, List <Asset> > > resultDict,
            Dictionary <NodeData, List <string> > cachedDict,
            List <string> performedIds,
            bool isActualRun,
            Action <NodeException> errorHandler,
            Action <NodeData, float> updateHandler
            )
        {
            if (performedIds.Contains(currentNodeData.Id) || (currentInputPoint != null && performedIds.Contains(currentInputPoint.Id)))
            {
                return;
            }

            /*
             * Find connections coming into this node from parent node, and traverse recursively
             */
            var connectionsToParents = saveData.Connections.FindAll(con => con.ToNodeId == currentNodeData.Id);

            foreach (var c in connectionsToParents)
            {
                var parentNode = saveData.Nodes.Find(node => node.Id == c.FromNodeId);
                UnityEngine.Assertions.Assert.IsNotNull(parentNode);

                // check if nodes can connect together
                ConnectionData.ValidateConnection(parentNode, currentNodeData);
                if (parentNode.InputPoints.Count > 0)
                {
                    // if node has multiple input, node is operated per input
                    foreach (var parentInputPoint in parentNode.InputPoints)
                    {
                        DoNodeOperation(target, parentNode, parentInputPoint, c, saveData, resultDict, cachedDict, performedIds, isActualRun, errorHandler, updateHandler);
                    }
                }
                // if parent does not have input point, call with inputPoint==null
                else
                {
                    DoNodeOperation(target, parentNode, null, c, saveData, resultDict, cachedDict, performedIds, isActualRun, errorHandler, updateHandler);
                }
            }

            // mark this point as performed
            if (currentInputPoint != null)
            {
                performedIds.Add(currentInputPoint.Id);
            }
            // Root node does not have input point, so we are storing node id instead.
            else
            {
                performedIds.Add(currentNodeData.Id);
            }

            /*
             * Perform node operation for this node
             */

            if (updateHandler != null)
            {
                updateHandler(currentNodeData, 0f);
            }

            /*
             *      has next node, run first time.
             */

            var alreadyCachedPaths = new List <string>();

            if (cachedDict.ContainsKey(currentNodeData))
            {
                alreadyCachedPaths.AddRange(cachedDict[currentNodeData]);
            }
            // load already exist cache from node.
            alreadyCachedPaths.AddRange(GetCachedDataByNode(target, currentNodeData));

            // Grab incoming assets from result by refering connections to parents
            var inputGroupAssets = new Dictionary <string, List <Asset> >();

            if (currentInputPoint != null)
            {
                // aggregates all input assets coming from current inputPoint
                var connToParentsFromCurrentInput = saveData.Connections.FindAll(con => con.ToNodeConnectionPointId == currentInputPoint.Id);
                foreach (var rCon in connToParentsFromCurrentInput)
                {
                    if (!resultDict.ContainsKey(rCon))
                    {
                        continue;
                    }

                    var result = resultDict[rCon];
                    foreach (var groupKey in result.Keys)
                    {
                        if (!inputGroupAssets.ContainsKey(groupKey))
                        {
                            inputGroupAssets[groupKey] = new List <Asset>();
                        }
                        inputGroupAssets[groupKey].AddRange(result[groupKey]);
                    }
                }
            }

            /*
             *      the Action passes to NodeOperaitons.
             *      It stores result to resultDict.
             */
            Action <ConnectionData, Dictionary <string, List <Asset> >, List <string> > Output =
                (ConnectionData destinationConnection, Dictionary <string, List <Asset> > outputGroupAsset, List <string> cachedItems) =>
            {
                if (destinationConnection != null)
                {
                    if (!resultDict.ContainsKey(destinationConnection))
                    {
                        resultDict[destinationConnection] = new Dictionary <string, List <Asset> >();
                    }

                    /*
                     * merge connection result by group key.
                     */
                    foreach (var groupKey in outputGroupAsset.Keys)
                    {
                        if (!resultDict[destinationConnection].ContainsKey(groupKey))
                        {
                            resultDict[destinationConnection][groupKey] = new List <Asset>();
                        }
                        resultDict[destinationConnection][groupKey].AddRange(outputGroupAsset[groupKey]);
                    }
                }

                if (isActualRun)
                {
                    if (!cachedDict.ContainsKey(currentNodeData))
                    {
                        cachedDict[currentNodeData] = new List <string>();
                    }
                    if (cachedItems != null)
                    {
                        cachedDict[currentNodeData].AddRange(cachedItems);
                    }
                }
            };

            try {
                INodeOperation executor = CreateOperation(saveData, currentNodeData, errorHandler);
                if (executor != null)
                {
                    if (isActualRun)
                    {
                        executor.Run(target, currentNodeData, currentInputPoint, connectionToOutput, inputGroupAssets, alreadyCachedPaths, Output);
                    }
                    else
                    {
                        executor.Setup(target, currentNodeData, currentInputPoint, connectionToOutput, inputGroupAssets, alreadyCachedPaths, Output);
                    }
                }
            } catch (NodeException e) {
                errorHandler(e);
                // since error occured, this node should stop running for other inputpoints. Adding node id to stop.
                if (!performedIds.Contains(currentNodeData.Id))
                {
                    performedIds.Add(currentNodeData.Id);
                }
            }

            if (updateHandler != null)
            {
                updateHandler(currentNodeData, 1f);
            }
        }
Example #5
0
        /**
         * Build from commandline - entrypoint.
         */
        public static void BuildFromCommandline()
        {
            try {
                var arguments = new List <string>(System.Environment.GetCommandLineArgs());

                Application.stackTraceLogType = StackTraceLogType.None;

                BuildTarget target = EditorUserBuildSettings.activeBuildTarget;

                int targetIndex = arguments.FindIndex(a => a == "-target");

                if (targetIndex >= 0)
                {
                    var targetStr = arguments[targetIndex + 1];
                    LogUtility.Logger.Log("Target specified:" + targetStr);

                    var newTarget = BuildTargetUtility.BuildTargetFromString(arguments[targetIndex + 1]);
                    if (!BuildTargetUtility.IsBuildTargetSupported(newTarget))
                    {
                        throw new AssetBundleGraphException(newTarget + " is not supported to build with this Unity. Please install platform support with installer(s).");
                    }

                    if (newTarget != target)
                    {
                                                #if UNITY_5_6
                        EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetUtility.TargetToGroup(newTarget), newTarget);
                                                #else
                        EditorUserBuildSettings.SwitchActiveBuildTarget(newTarget);
                                                #endif
                        target = newTarget;
                    }
                }

                LogUtility.Logger.Log("AssetReference bundle building for:" + BuildTargetUtility.TargetToHumaneString(target));

                if (!SaveData.IsSaveDataAvailableAtDisk())
                {
                    LogUtility.Logger.Log("AssetBundleGraph save data not found. Aborting...");
                    return;
                }

                // load data from file.
                AssetBundleGraphController c = new AssetBundleGraphController();

                // perform setup. Fails if any exception raises.
                c.Perform(target, false, true, null);

                // if there is error reported, then run
                if (c.IsAnyIssueFound)
                {
                    LogUtility.Logger.Log("Build terminated because following error found during Setup phase. Please fix issues by opening editor before building.");
                    c.Issues.ForEach(e => LogUtility.Logger.LogError(LogUtility.kTag, e));

                    return;
                }

                NodeData lastNodeData = null;
                float    lastProgress = 0.0f;

                Action <NodeData, string, float> updateHandler = (NodeData node, string message, float progress) => {
                    if (node != null && lastNodeData != node)
                    {
                        lastNodeData = node;
                        lastProgress = progress;

                        LogUtility.Logger.LogFormat(LogType.Log, "Processing {0}", node.Name);
                    }
                    if (progress > lastProgress)
                    {
                        if (progress <= 1.0f)
                        {
                            LogUtility.Logger.LogFormat(LogType.Log, "{0} Complete.", node.Name);
                        }
                        else if ((progress - lastProgress) > 0.2f)
                        {
                            LogUtility.Logger.LogFormat(LogType.Log, "{0}: {1} % : {2}", node.Name, (int)progress * 100f, message);
                        }
                        lastProgress = progress;
                    }
                };

                // run datas.
                c.Perform(target, true, true, updateHandler);

                AssetDatabase.Refresh();
            } catch (Exception e) {
                LogUtility.Logger.LogError(LogUtility.kTag, e);
                LogUtility.Logger.LogError(LogUtility.kTag, "Building asset bundles terminated due to unexpected error.");
            } finally {
                LogUtility.Logger.Log("End of build.");
            }
        }
Example #6
0
 public static SaveData Reload()
 {
     s_saveData = null;
     return(Data);
 }