Пример #1
0
        void Load(BuildTarget target,
                  Model.NodeData node,
                  IEnumerable <Model.ConnectionData> connectionsToOutput,
                  PerformGraph.Output Output)
        {
            if (connectionsToOutput == null || Output == null)
            {
                return;
            }

            var outputSource = new List <AssetReference>();

            var loadPath    = GetLoadPath(target);
            var targetFiles = AssetDatabase.FindAssets("", new string[] { loadPath });

            foreach (var assetGuid in targetFiles)
            {
                var targetFilePath = AssetDatabase.GUIDToAssetPath(assetGuid);

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

                // Skip folders
                var type = TypeUtility.GetMainAssetTypeAtPath(targetFilePath);
                if (type == typeof(UnityEditor.DefaultAsset) && AssetDatabase.IsValidFolder(targetFilePath))
                {
                    continue;
                }

                var r = AssetReferenceDatabase.GetReference(targetFilePath);

                if (r == null)
                {
                    continue;
                }

                if (outputSource.Contains(r))
                {
                    continue;
                }

                if (IsIgnored(targetFilePath))
                {
                    continue;
                }

                outputSource.Add(r);
            }

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

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

            Output(dst, output);
        }
Пример #2
0
        void Load(BuildTarget target,
                  Model.NodeData node,
                  IEnumerable <Model.ConnectionData> connectionsToOutput,
                  PerformGraph.Output Output)
        {
            if (connectionsToOutput == null || Output == null)
            {
                return;
            }

            var cond         = m_searchFilter[target];
            var outputSource = new List <AssetReference>();

            var guids = AssetDatabase.FindAssets(cond);

            foreach (var guid in guids)
            {
                var targetFilePath = AssetDatabase.GUIDToAssetPath(guid);

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


                var r = AssetReferenceDatabase.GetReference(targetFilePath);

                if (r != null)
                {
                    outputSource.Add(AssetReferenceDatabase.GetReference(targetFilePath));
                }
            }

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

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

            Output(dst, output);
        }
        public void Init(Stack <AssetPostprocessorContext> ctxStack)
        {
            m_importedAssets = new List <AssetReference>();
            m_movedAssets    = new List <AssetReference>();

            foreach (var path in m_importedAssetPaths)
            {
                if (!TypeUtility.IsLoadingAsset(path))
                {
                    continue;
                }
                bool isAssetFoundInStack = false;

                foreach (var ctx in ctxStack)
                {
                    if (ArrayUtility.Contains(ctx.ImportedAssetPaths, path) ||
                        ctx.ImportedAssets.Find(a => a.importFrom == path) != null)
                    {
                        isAssetFoundInStack = true;
                        break;
                    }
                }
                if (!isAssetFoundInStack)
                {
                    var a = AssetReferenceDatabase.GetReference(path);
                    m_importedAssets.Add(a);
                }
            }

            for (int i = 0; i < m_movedAssetPaths.Length; ++i)
            {
                var movedTo = m_movedAssetPaths [i];

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

                var a = AssetReferenceDatabase.GetReference(movedTo);
                m_movedAssets.Add(a);
            }
        }