Exemplo n.º 1
0
            private static void DrawRootDirInfo(AssetBundleOrganizerConfig.RootDirectoryInfo info)
            {
                EditorGUILayout.BeginVertical();
                {
                    var cachedLabelWidth = EditorGUIUtility.labelWidth;
                    EditorGUIUtility.labelWidth = DefaultLabelWidth;
                    var assetObj    = AssetDatabase.LoadAssetAtPath <Object>(AssetDatabase.GUIDToAssetPath(info.DirectoryGuid));
                    var newAssetObj = EditorGUILayout.ObjectField("Root Dir", assetObj, typeof(Object), false);
                    if (newAssetObj != assetObj)
                    {
                        var newAssetPath = AssetDatabase.GetAssetPath(newAssetObj);
                        if (AssetDatabase.IsValidFolder(newAssetPath))
                        {
                            info.DirectoryGuid = AssetDatabase.AssetPathToGUID(newAssetPath);
                        }
                        else if (newAssetObj == null)
                        {
                            info.DirectoryGuid = string.Empty;
                        }
                    }

                    info.Filter = EditorGUILayout.DelayedTextField("Filter", info.Filter);
                    EditorGUIUtility.labelWidth = cachedLabelWidth;
                }
                EditorGUILayout.EndVertical();
            }
 private bool AssetIsInSubRootDir(AssetBundleOrganizerConfig.RootDirectoryInfo rootDir, string rootAssetPath, string assetPath)
 {
     return(m_ConfigCache.RootDirectoryInfos.Any(dirInfo
                                                 => dirInfo != rootDir &&
                                                 AssetDatabase.GUIDToAssetPath(dirInfo.DirectoryGuid).StartsWith(rootAssetPath) &&
                                                 assetPath.StartsWith(AssetDatabase.GUIDToAssetPath(dirInfo.DirectoryGuid))));
 }
        private int CompareRootAssetDirectories(AssetBundleOrganizerConfig.RootDirectoryInfo a,
                                                AssetBundleOrganizerConfig.RootDirectoryInfo b)
        {
            if (a.DirectoryGuid == null && b.DirectoryGuid == null)
            {
                return(0);
            }

            if (a.DirectoryGuid == null)
            {
                return(-1);
            }

            if (b.DirectoryGuid == null)
            {
                return(1);
            }

            return(AssetDatabase.GUIDToAssetPath(a.DirectoryGuid).CompareTo(AssetDatabase.GUIDToAssetPath(b.DirectoryGuid)));
        }
        private void BuildAssetTree(AssetBundleOrganizerConfig.RootDirectoryInfo rootDir)
        {
            if (rootDir.DirectoryGuid == null)
            {
                return;
            }

            var rootDirAssetPath = AssetDatabase.GUIDToAssetPath(rootDir.DirectoryGuid);

            if (string.IsNullOrEmpty(rootDirAssetPath) || Utility.Path.IsEditor(rootDirAssetPath))
            {
                return;
            }

            var rootDirAssetObj = AssetDatabase.LoadAssetAtPath <Object>(rootDirAssetPath);

            if (rootDirAssetObj == null)
            {
                return;
            }

            var root = new AssetInfo
            {
                Guid = rootDir.DirectoryGuid,
                Name = rootDirAssetObj.name,
            };

            root.AssetBundlePath = GetAssetBundlePath(root.Path);
            if (root.IsNullOrMissing)
            {
                return;
            }

            m_AssetInfoForestRoots.Add(root);
            m_IncludedAssetGuidToInfoMap.Add(root.Guid, root);

            var assetGuids = AssetDatabase.FindAssets(rootDir.Filter, new[] { root.Path });

            foreach (var assetGuid in assetGuids)
            {
                var assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
                if (AssetIsInSubRootDir(rootDir, root.Path, assetPath))
                {
                    continue;
                }

                if (string.IsNullOrEmpty(assetPath) || Utility.Path.IsEditor(assetPath))
                {
                    continue;
                }

                if (AssetDatabase.IsValidFolder(assetPath))
                {
                    continue;
                }

                var mainAssetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
                if (mainAssetType == typeof(MonoScript))
                {
                    continue;
                }

                var assetRelPathToRoot = Regex.Replace(assetPath, @"^" + root.Path, string.Empty);
                assetRelPathToRoot = Regex.Replace(assetRelPathToRoot, @"^/", string.Empty);
                var assetRelPathSegments = assetRelPathToRoot.Split('/');
                var node           = root;
                var currentRelPath = string.Empty;
                for (int i = 0; i < assetRelPathSegments.Length; i++)
                {
                    var segment = assetRelPathSegments[i];
                    currentRelPath += currentRelPath == string.Empty ? segment : ("/" + segment);

                    if (node.Children.ContainsKey(segment))
                    {
                        node = node.Children[segment];
                    }
                    else
                    {
                        var newAssetPath = root.Path + "/" + currentRelPath;
                        var guid         = AssetDatabase.AssetPathToGUID(newAssetPath);
                        var newNode      = new AssetInfo
                        {
                            Name            = segment,
                            Guid            = guid,
                            Parent          = node,
                            AssetBundlePath = GetAssetBundlePath(newAssetPath),
                        };

                        node.Children.Add(segment, newNode);
                        node = newNode;
                        m_IncludedAssetGuidToInfoMap.Add(node.Guid, node);
                    }
                }
            }
        }