예제 #1
0
        private void UpdateVariant(Model.NodeData n, Variant variant)
        {
            Model.ConnectionPointData p = n.InputPoints.Find(v => v.Id == variant.ConnectionPointId);
            UnityEngine.Assertions.Assert.IsNotNull(p);

            p.Label = variant.Name;
        }
예제 #2
0
        public override void Prepare(BuildTarget target,
                                     Model.NodeData node,
                                     IEnumerable <PerformGraph.AssetGroups> incoming,
                                     IEnumerable <Model.ConnectionData> connectionsToOutput,
                                     PerformGraph.Output Output)
        {
            // Label does not add, filter or change structure of group, so just pass given group of assets
            if (Output != null)
            {
                var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
                          null : connectionsToOutput.First();

                if (incoming != null)
                {
                    foreach (var ag in incoming)
                    {
                        Output(dst, ag.assetGroups);
                    }
                }
                else
                {
                    Output(dst, new Dictionary <string, List <AssetReference> >());
                }
            }
        }
예제 #3
0
 public void Import(V1.NodeData v1, Model.NodeData v2)
 {
     foreach (var f in v1.FilterConditions)
     {
         m_filter.Add(new FilterEntry(new FilterByNameAndType(f.FilterKeyword, f.FilterKeytype), v2.FindOutputPoint(f.ConnectionPointId)));
     }
 }
예제 #4
0
        public override Node Clone(Model.NodeData newData)
        {
            var newNode = new Imported();

            newData.AddDefaultOutputPoint();
            return(newNode);
        }
예제 #5
0
        public ExportReport(Model.NodeData node)
        {
            m_nodeData = node;

            m_exportedItems = new List <Entry>();
            m_failedItems   = new List <ErrorEntry> ();
        }
예제 #6
0
        static public bool DoesPrefabNeedRebuilding(PrefabBuilder builder, Model.NodeData node, BuildTarget target, string groupKey, List <AssetReference> assets)
        {
            var buildInfo = GetPrefabBuildInfo(builder, node, target, groupKey);

            // need rebuilding if no buildInfo found
            if (buildInfo == null)
            {
                return(true);
            }

            // need rebuilding if given builder is changed
            if (buildInfo.m_builderClass != builder.Builder.ClassName)
            {
                return(true);
            }

            // need rebuilding if given builder is changed
            if (buildInfo.m_instanceData != builder.Builder[target])
            {
                return(true);
            }

            // need rebuilding if replace prefab option is changed
            if (buildInfo.m_replacePrefabOptions != (int)builder.Options)
            {
                return(true);
            }

            var builderVersion = PrefabBuilderUtility.GetPrefabBuilderVersion(builder.Builder.ClassName);

            // need rebuilding if given builder version is changed
            if (buildInfo.m_prefabBuilderVersion != builderVersion)
            {
                return(true);
            }

            // need rebuilding if given groupKey changed
            if (buildInfo.m_groupKey != groupKey)
            {
                return(true);
            }

            if (!Enumerable.SequenceEqual(
                    buildInfo.m_usedAssets.Select(v => v.importFrom).OrderBy(s => s),
                    assets.Select(v => v.importFrom).OrderBy(s => s)))
            {
                return(true);
            }

            // If any asset is modified from last time, then need rebuilding
            foreach (var usedAsset in buildInfo.m_usedAssets)
            {
                if (usedAsset.IsAssetModifiedFromLastTime)
                {
                    return(true);
                }
            }

            return(false);
        }
예제 #7
0
        private AssetImporter GetReferenceAssetImporter(Model.NodeData node, bool allowCustom)
        {
            if (allowCustom)
            {
                if (m_useCustomSettingAsset)
                {
                    if (CustomSettingAsset != null)
                    {
                        var path = AssetDatabase.GUIDToAssetPath(CustomSettingAssetGuid);
                        return(AssetImporter.GetAtPath(path));
                    }
                    return(null);
                }
            }

            var sampleFileDir = FileUtility.PathCombine(Model.Settings.Path.ImporterSettingsPath, node.Id);

            UnityEngine.Assertions.Assert.IsTrue(Directory.Exists(sampleFileDir));

            var sampleFiles = FileUtility.GetFilePathsInFolder(sampleFileDir)
                              .Where(path => !path.EndsWith(Model.Settings.UNITY_METAFILE_EXTENSION))
                              .ToList();

            UnityEngine.Assertions.Assert.IsTrue(sampleFiles.Count == 1);

            return(AssetImporter.GetAtPath(sampleFiles[0]));
        }
예제 #8
0
        static private PrefabBuildInfo GetPrefabBuildInfo(PrefabBuilder builder, Model.NodeData node, BuildTarget target, string groupKey)
        {
            var prefabCacheDir = FileUtility.EnsurePrefabBuilderCacheDirExists(target, node);
            var buildInfoPath  = FileUtility.PathCombine(prefabCacheDir, groupKey + ".asset");

            return(AssetDatabase.LoadAssetAtPath <PrefabBuildInfo>(buildInfoPath));
        }
예제 #9
0
        private void MarkAndTraverseParent(Model.ConfigGraph saveData, Model.NodeData current, List <Model.ConnectionData> visitedConnections, List <Model.NodeData> visitedNode)
        {
//			Assert.IsNotNull(current);
            if (current == null)
            {
                return;
            }

            // if node is visited from other route, just quit
            if (visitedNode.Contains(current))
            {
                return;
            }

            var connectionsToParents = saveData.Connections.FindAll(con => con.ToNodeId == current.Id);

            foreach (var c in connectionsToParents)
            {
                if (visitedConnections.Contains(c))
                {
                    throw new NodeException("Looped connection detected. Please fix connections to avoid loop.", current.Id);
                }

                visitedConnections.Add(c);

                var parentNode = saveData.Nodes.Find(node => node.Id == c.FromNodeId);
                if (parentNode != null)
                {
                    // parentNode may be null while deleting node
                    MarkAndTraverseParent(saveData, parentNode, visitedConnections, visitedNode);
                }
            }

            visitedNode.Add(current);
        }
예제 #10
0
        public override void Initialize(Model.NodeData data)
        {
            m_instance = new SerializableMultiTargetInstance();

            data.AddDefaultInputPoint();
            data.AddDefaultOutputPoint();
        }
예제 #11
0
        public void UpdateFilterEntry(Model.NodeData n, FilterEntry f)
        {
            Model.ConnectionPointData p = n.OutputPoints.Find(v => v.Id == f.ConnectionPointId);
            UnityEngine.Assertions.Assert.IsNotNull(p);

            p.Label = f.Instance.Object.Label;
        }
예제 #12
0
        void Load(BuildTarget target,
                  Model.NodeData node,
                  IEnumerable <Model.ConnectionData> connectionsToOutput,
                  PerformGraph.Output Output)
        {
            if (connectionsToOutput == null || Output == null)
            {
                return;
            }

            // SOMEWHERE_FULLPATH/PROJECT_FOLDER/Assets/
            var assetsFolderPath = Application.dataPath + Model.Settings.UNITY_FOLDER_SEPARATOR;

            var outputSource    = new List <AssetReference>();
            var targetFilePaths = FileUtility.GetAllFilePathsInFolder(GetLoaderFullLoadPath(target));

            foreach (var targetFilePath in targetFilePaths)
            {
                // already contained into Assets/ folder.
                // imported path is Assets/SOMEWHERE_FILE_EXISTS.
                if (targetFilePath.StartsWith(assetsFolderPath))
                {
                    var relativePath = targetFilePath.Replace(assetsFolderPath, Model.Settings.Path.ASSETS_PATH);

                    if (TypeUtility.IsGraphToolSystemAsset(relativePath))
                    {
                        continue;
                    }

                    var r = AssetReferenceDatabase.GetReference(relativePath);

                    if (r == null)
                    {
                        continue;
                    }

                    if (!TypeUtility.IsLoadingAsset(r))
                    {
                        continue;
                    }

                    if (r != null)
                    {
                        outputSource.Add(r);
                    }
                    continue;
                }

                throw new NodeException(node.Name + ": Invalid Load Path. Path must start with Assets/", node.Name);
            }

            var output = new Dictionary <string, List <AssetReference> > {
                { "0", outputSource }
            };

            var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
                      null : connectionsToOutput.First();

            Output(dst, output);
        }
예제 #13
0
 public override void Initialize(Model.NodeData data)
 {
     m_path  = new SerializableMultiTargetString();
     m_style = AssertionStyle.AllowOnlyAssetsUnderAssertionPath;
     data.AddDefaultInputPoint();
     data.AddDefaultOutputPoint();
 }
예제 #14
0
        public void UpdateGeneratorEntry(Model.NodeData n, GeneratorEntry e)
        {
            Model.ConnectionPointData p = n.OutputPoints.Find(v => v.Id == e.m_id);
            UnityEngine.Assertions.Assert.IsNotNull(p);

            p.Label = e.m_name;
        }
예제 #15
0
        private void Mirror(BuildTarget target,
                            Model.NodeData node,
                            IEnumerable <PerformGraph.AssetGroups> incoming,
                            IEnumerable <Model.ConnectionData> connectionsToOutput,
                            Action <Model.NodeData, string, float> progressFunc)
        {
            try {
                var srcDir = GetNormalizedPath(m_srcPath[target]);
                var dstDir = GetNormalizedPath(m_dstPath[target]);

                if (Directory.Exists(dstDir))
                {
                    if (m_mirrorOption[target] == (int)MirrorOption.AlwaysRecreateDestination)
                    {
                        FileUtility.DeleteDirectory(dstDir, true);
                    }
                    else if (m_mirrorOption[target] == (int)MirrorOption.KeepAlreadyCopiedFiles)
                    {
                        var dstFilePaths = FileUtility.GetAllFilePathsInFolder(dstDir);
                        // checking destination files - remove files if not exist in source
                        foreach (var dstPath in dstFilePaths)
                        {
                            var srcPath = dstPath.Replace(dstDir, srcDir);
                            if (!File.Exists(srcPath))
                            {
                                File.Delete(dstPath);
                            }
                        }
                    }
                }

                var targetFilePaths = FileUtility.GetAllFilePathsInFolder(srcDir);
                int i = 0;

                foreach (var srcPath in targetFilePaths)
                {
                    var dstPath = srcPath.Replace(srcDir, dstDir);

                    var dstParentDir = Directory.GetParent(dstPath);
                    if (!dstParentDir.Exists)
                    {
                        var dirPath = dstParentDir.ToString();
                        Directory.CreateDirectory(dirPath);
                    }

                    var srcInfo = new FileInfo(srcPath);
                    var dstInfo = new FileInfo(dstPath);

                    if (!dstInfo.Exists ||
                        srcInfo.LastWriteTimeUtc > dstInfo.LastWriteTimeUtc)
                    {
                        File.Copy(srcPath, dstPath, true);
                        progressFunc(node, string.Format("Copying {0}", Path.GetFileName(srcPath)), (float)(i++) / (float)targetFilePaths.Count);
                    }
                }
            } catch (Exception e) {
                throw new NodeException(node.Name + ":" + e.Message, node.Id);
            }
        }
예제 #16
0
        private void AddVariant(Model.NodeData n, string name)
        {
            var p        = n.AddInputPoint(name);
            var newEntry = new Variant(name, p);

            m_variants.Add(newEntry);
            UpdateVariant(n, newEntry);
        }
예제 #17
0
        public void AddFilterCondition(Model.NodeData n, IFilter filter)
        {
            var point    = n.AddOutputPoint(filter.Label);
            var newEntry = new FilterEntry(filter, point);

            m_filter.Add(newEntry);
            UpdateFilterEntry(n, newEntry);
        }
예제 #18
0
        public void AddEntry(Model.NodeData n, GeneratorEntry src)
        {
            var point    = n.AddOutputPoint(src.m_name);
            var newEntry = new GeneratorEntry(src.m_name, src.m_instance, point);

            m_entries.Add(newEntry);
            UpdateGeneratorEntry(n, newEntry);
        }
예제 #19
0
        public void AddEntry(Model.NodeData n)
        {
            var point    = n.AddOutputPoint("");
            var newEntry = new GeneratorEntry("", point);

            m_entries.Add(newEntry);
            UpdateGeneratorEntry(n, newEntry);
        }
예제 #20
0
 /// <summary>
 /// Prepare is the method which validates and perform necessary setups in order to build.
 /// </summary>
 /// <param name="target">Target platform.</param>
 /// <param name="nodeData">NodeData instance for this node.</param>
 /// <param name="incoming">Incoming group of assets for this node on executing graph.</param>
 /// <param name="connectionsToOutput">Outgoing connections from this node.</param>
 /// <param name="outputFunc">An interface to set outgoing group of assets.</param>
 public virtual void Prepare(BuildTarget target,
                             Model.NodeData nodeData,
                             IEnumerable <PerformGraph.AssetGroups> incoming,
                             IEnumerable <Model.ConnectionData> connectionsToOutput,
                             PerformGraph.Output outputFunc)
 {
     // Do nothing
 }
예제 #21
0
        public override void Initialize(Model.NodeData data)
        {
            m_groupSizeByte = new SerializableMultiTargetInt();
            m_groupingType  = new SerializableMultiTargetInt();

            data.AddDefaultInputPoint();
            data.AddDefaultOutputPoint();
        }
예제 #22
0
        public override Node Clone(Model.NodeData newData)
        {
            var newNode = new GroupingByFile();

            newData.AddDefaultInputPoint();
            newData.AddDefaultOutputPoint();
            return(newNode);
        }
예제 #23
0
 public override void Prepare(BuildTarget target,
                              Model.NodeData node,
                              IEnumerable <PerformGraph.AssetGroups> incoming,
                              IEnumerable <Model.ConnectionData> connectionsToOutput,
                              PerformGraph.Output Output)
 {
     GroupingOutput(target, node, incoming, connectionsToOutput, Output);
 }
예제 #24
0
 public override void Initialize(Model.NodeData data)
 {
     m_bundleNameTemplate   = "shared_*";
     m_groupExtractedAssets = new SerializableMultiTargetInt();
     m_groupSizeByte        = new SerializableMultiTargetInt();
     m_groupingType         = new SerializableMultiTargetInt();
     data.AddDefaultInputPoint();
     data.AddDefaultOutputPoint();
 }
예제 #25
0
        private void GroupingOutput(BuildTarget target,
                                    Model.NodeData node,
                                    IEnumerable <PerformGraph.AssetGroups> incoming,
                                    IEnumerable <Model.ConnectionData> connectionsToOutput,
                                    PerformGraph.Output Output)
        {
            ValidateGroupingKeyword(
                m_groupSizeByte[target],
                () => {
                throw new NodeException("Invalid size.", node.Id);
            }
                );

            if (connectionsToOutput == null || Output == null)
            {
                return;
            }

            var  outputDict = new Dictionary <string, List <AssetReference> >();
            long szGroup    = m_groupSizeByte[target] * 1000;

            int  groupCount   = 0;
            long szGroupCount = 0;
            var  groupName    = groupCount.ToString();

            if (incoming != null)
            {
                foreach (var ag in incoming)
                {
                    foreach (var assets in ag.assetGroups.Values)
                    {
                        foreach (var a in assets)
                        {
                            szGroupCount += GetSizeOfAsset(a, (GroupingType)m_groupingType[target]);

                            if (!outputDict.ContainsKey(groupName))
                            {
                                outputDict[groupName] = new List <AssetReference>();
                            }
                            outputDict[groupName].Add(a);

                            if (szGroupCount >= szGroup)
                            {
                                szGroupCount = 0;
                                ++groupCount;
                                groupName = groupCount.ToString();
                            }
                        }
                    }
                }
            }

            var dst = (connectionsToOutput == null || !connectionsToOutput.Any())?
                      null : connectionsToOutput.First();

            Output(dst, outputDict);
        }
예제 #26
0
        public override Node Clone(Model.NodeData newData)
        {
            var newNode = new LoaderBySearch();

            newNode.m_searchFilter = new SerializableMultiTargetString(m_searchFilter);

            newData.AddDefaultOutputPoint();
            return(newNode);
        }
예제 #27
0
 public override void Initialize(Model.NodeData data)
 {
     m_buildOptions   = new SerializableMultiTargetInt();
     m_buildLocations = new SerializableMultiTargetString();
     m_playerName     = new SerializableMultiTargetString();
     m_scenes         = new SerializableMultiTargetString();
     data.AddDefaultInputPoint();
     m_scroll = Vector2.zero;
 }
예제 #28
0
        public override void Initialize(Model.NodeData data)
        {
            m_groupingKeyword = new SerializableMultiTargetString(Model.Settings.GROUPING_KEYWORD_DEFAULT);
            m_patternType     = new SerializableMultiTargetInt((int)GroupingPatternType.WildCard);
            m_allowSlash      = false;

            data.AddDefaultInputPoint();
            data.AddDefaultOutputPoint();
        }
예제 #29
0
        public override void Initialize(Model.NodeData data)
        {
            m_enabledBundleOptions = new SerializableMultiTargetInt();
            m_outputDir            = new SerializableMultiTargetString();
            m_outputOption         = new SerializableMultiTargetInt((int)OutputOption.BuildInCacheDirectory);

            data.AddDefaultInputPoint();
            data.AddDefaultOutputPoint();
        }
예제 #30
0
 /// <summary>
 /// Build is the method which actualy performs the build. It is always called after Setup() is performed.
 /// </summary>
 /// <param name="target">Target platform.</param>
 /// <param name="nodeData">NodeData instance for this node.</param>
 /// <param name="incoming">Incoming group of assets for this node on executing graph.</param>
 /// <param name="connectionsToOutput">Outgoing connections from this node.</param>
 /// <param name="outputFunc">An interface to set outgoing group of assets.</param>
 /// <param name="progressFunc">An interface to display progress.</param>
 public virtual void Build(BuildTarget target,
                           Model.NodeData nodeData,
                           IEnumerable <PerformGraph.AssetGroups> incoming,
                           IEnumerable <Model.ConnectionData> connectionsToOutput,
                           PerformGraph.Output outputFunc,
                           Action <Model.NodeData, string, float> progressFunc)
 {
     // Do nothing
 }