Beispiel #1
0
 private static void CollectNode(GameObjectTreeNode node, List <GameObject> gameObjects)
 {
     gameObjects.Add(node.gameObject);
     foreach (GameObjectTreeNode i in node.Nodes)
     {
         CollectNode(i, gameObjects);
     }
 }
Beispiel #2
0
        public static void BuildAssetStructures(bool loadAssets, bool displayAll, bool buildHierarchy, bool buildClassStructures, bool displayOriginalName)
        {
            var tempDic = new Dictionary <ObjectReader, AssetItem>();

            // first loop - read asset data & create list
            if (loadAssets)
            {
                SetProgressBarValue(0);
                SetProgressBarMaximum(assetsfileList.Sum(x => x.ObjectReaders.Count));
                StatusStripUpdate("Building asset list...");

                var fileIDfmt = "D" + assetsfileList.Count.ToString().Length;

                for (var i = 0; i < assetsfileList.Count; i++)
                {
                    var         assetsFile           = assetsfileList[i];
                    var         tempExportableAssets = new List <AssetItem>();
                    var         fileID     = i.ToString(fileIDfmt);
                    AssetBundle ab         = null;
                    var         j          = 0;
                    var         assetIDfmt = "D" + assetsFile.m_Objects.Count.ToString().Length;
                    foreach (var objectReader in assetsFile.ObjectReaders.Values)
                    {
                        var assetItem = new AssetItem(objectReader);
                        tempDic.Add(objectReader, assetItem);
                        assetItem.UniqueID = fileID + j.ToString(assetIDfmt);
                        var exportable = false;
                        switch (assetItem.Type)
                        {
                        case ClassIDType.GameObject:
                        {
                            var m_GameObject = new GameObject(objectReader);
                            assetItem.Text = m_GameObject.m_Name;
                            assetsFile.GameObjects.Add(objectReader.m_PathID, m_GameObject);
                            break;
                        }

                        case ClassIDType.Transform:
                        {
                            var m_Transform = new Transform(objectReader);
                            assetsFile.Transforms.Add(objectReader.m_PathID, m_Transform);
                            break;
                        }

                        case ClassIDType.RectTransform:
                        {
                            var m_Rect = new RectTransform(objectReader);
                            assetsFile.Transforms.Add(objectReader.m_PathID, m_Rect);
                            break;
                        }

                        case ClassIDType.Texture2D:
                        {
                            var m_Texture2D = new Texture2D(objectReader, false);
                            if (!string.IsNullOrEmpty(m_Texture2D.path))
                            {
                                assetItem.FullSize = objectReader.byteSize + m_Texture2D.size;
                            }
                            goto case ClassIDType.NamedObject;
                        }

                        case ClassIDType.AudioClip:
                        {
                            var m_AudioClip = new AudioClip(objectReader, false);
                            if (!string.IsNullOrEmpty(m_AudioClip.m_Source))
                            {
                                assetItem.FullSize = objectReader.byteSize + m_AudioClip.m_Size;
                            }
                            goto case ClassIDType.NamedObject;
                        }

                        case ClassIDType.VideoClip:
                        {
                            var m_VideoClip = new VideoClip(objectReader, false);
                            if (!string.IsNullOrEmpty(m_VideoClip.m_OriginalPath))
                            {
                                assetItem.FullSize = objectReader.byteSize + (long)m_VideoClip.m_Size;
                            }
                            goto case ClassIDType.NamedObject;
                        }

                        case ClassIDType.NamedObject:
                        case ClassIDType.Mesh:
                        case ClassIDType.Shader:
                        case ClassIDType.TextAsset:
                        case ClassIDType.AnimationClip:
                        case ClassIDType.Font:
                        case ClassIDType.MovieTexture:
                        case ClassIDType.Sprite:
                        {
                            var obj = new NamedObject(objectReader);
                            assetItem.Text = obj.m_Name;
                            exportable     = true;
                            break;
                        }

                        case ClassIDType.Avatar:
                        case ClassIDType.AnimatorController:
                        case ClassIDType.AnimatorOverrideController:
                        case ClassIDType.Material:
                        case ClassIDType.MonoScript:
                        case ClassIDType.SpriteAtlas:
                        {
                            var obj = new NamedObject(objectReader);
                            assetItem.Text = obj.m_Name;
                            break;
                        }

                        case ClassIDType.Animator:
                        {
                            exportable = true;
                            break;
                        }

                        case ClassIDType.MonoBehaviour:
                        {
                            var m_MonoBehaviour = new MonoBehaviour(objectReader);
                            if (m_MonoBehaviour.m_Name == "" && m_MonoBehaviour.m_Script.TryGet(out var script))
                            {
                                var m_Script = new MonoScript(script);
                                assetItem.Text = m_Script.m_ClassName;
                            }
                            else
                            {
                                assetItem.Text = m_MonoBehaviour.m_Name;
                            }
                            exportable = true;
                            break;
                        }

                        case ClassIDType.PlayerSettings:
                        {
                            var plSet = new PlayerSettings(objectReader);
                            productName = plSet.productName;
                            break;
                        }

                        case ClassIDType.AssetBundle:
                        {
                            ab             = new AssetBundle(objectReader);
                            assetItem.Text = ab.m_Name;
                            break;
                        }
                        }
                        if (assetItem.Text == "")
                        {
                            assetItem.Text = assetItem.TypeString + " #" + assetItem.UniqueID;
                        }
                        assetItem.SubItems.AddRange(new[] { assetItem.TypeString, assetItem.FullSize.ToString() });
                        //处理同名文件
                        if (!assetsNameHash.Add((assetItem.TypeString + assetItem.Text).ToUpper()))
                        {
                            assetItem.Text += " #" + assetItem.UniqueID;
                        }
                        //处理非法文件名
                        assetItem.Text = FixFileName(assetItem.Text);
                        if (displayAll)
                        {
                            exportable = true;
                        }
                        if (exportable)
                        {
                            tempExportableAssets.Add(assetItem);
                        }
                        objectReader.exportName = assetItem.Text;

                        ProgressBarPerformStep();
                        j++;
                    }
                    if (displayOriginalName)
                    {
                        foreach (var x in tempExportableAssets)
                        {
                            var replacename = ab?.m_Container.Find(y => y.second.asset.m_PathID == x.reader.m_PathID)?.first;
                            if (!string.IsNullOrEmpty(replacename))
                            {
                                var ex = Path.GetExtension(replacename);
                                x.Text = !string.IsNullOrEmpty(ex) ? replacename.Replace(ex, "") : replacename;
                                x.reader.exportName = x.Text;
                            }
                        }
                    }
                    exportableAssets.AddRange(tempExportableAssets);
                    tempExportableAssets.Clear();
                }

                visibleAssets = exportableAssets;
                assetsNameHash.Clear();
            }

            // second loop - build tree structure
            if (buildHierarchy)
            {
                var gameObjectCount = assetsfileList.Sum(x => x.GameObjects.Count);
                if (gameObjectCount > 0)
                {
                    SetProgressBarValue(0);
                    SetProgressBarMaximum(gameObjectCount);
                    StatusStripUpdate("Building tree structure...");

                    foreach (var assetsFile in assetsfileList)
                    {
                        var fileNode = new GameObjectTreeNode(null); //RootNode
                        fileNode.Text = assetsFile.fileName;

                        foreach (var m_GameObject in assetsFile.GameObjects.Values)
                        {
                            foreach (var m_Component in m_GameObject.m_Components)
                            {
                                if (m_Component.TryGet(out var asset))
                                {
                                    switch (asset.type)
                                    {
                                    case ClassIDType.Transform:
                                    {
                                        m_GameObject.m_Transform = m_Component;
                                        break;
                                    }

                                    case ClassIDType.MeshRenderer:
                                    {
                                        m_GameObject.m_MeshRenderer = m_Component;
                                        break;
                                    }

                                    case ClassIDType.MeshFilter:
                                    {
                                        m_GameObject.m_MeshFilter = m_Component;
                                        if (m_Component.TryGet(out var objectReader))
                                        {
                                            var m_MeshFilter = new MeshFilter(objectReader);
                                            if (m_MeshFilter.m_Mesh.TryGet(out objectReader))
                                            {
                                                var item = tempDic[objectReader];
                                                item.gameObject = m_GameObject;
                                            }
                                        }
                                        break;
                                    }

                                    case ClassIDType.SkinnedMeshRenderer:
                                    {
                                        m_GameObject.m_SkinnedMeshRenderer = m_Component;
                                        if (m_Component.TryGet(out var objectReader))
                                        {
                                            var m_SkinnedMeshRenderer = new SkinnedMeshRenderer(objectReader);
                                            if (m_SkinnedMeshRenderer.m_Mesh.TryGet(out objectReader))
                                            {
                                                var item = tempDic[objectReader];
                                                item.gameObject = m_GameObject;
                                            }
                                        }
                                        break;
                                    }

                                    case ClassIDType.Animator:
                                    {
                                        m_GameObject.m_Animator = m_Component;
                                        var item = tempDic[asset];
                                        item.Text        = m_GameObject.reader.exportName;
                                        asset.exportName = m_GameObject.reader.exportName;
                                        break;
                                    }
                                    }
                                }
                            }

                            var parentNode = fileNode;

                            if (m_GameObject.m_Transform != null && m_GameObject.m_Transform.TryGetTransform(out var m_Transform))
                            {
                                if (m_Transform.m_Father.TryGetTransform(out var m_Father))
                                {
                                    if (m_Father.m_GameObject.TryGetGameObject(out var parentGameObject))
                                    {
                                        if (!treeNodeDictionary.TryGetValue(parentGameObject, out parentNode))
                                        {
                                            parentNode = new GameObjectTreeNode(parentGameObject);
                                            treeNodeDictionary.Add(parentGameObject, parentNode);
                                        }
                                    }
                                }
                            }

                            if (!treeNodeDictionary.TryGetValue(m_GameObject, out var currentNode))
                            {
                                currentNode = new GameObjectTreeNode(m_GameObject);
                                treeNodeDictionary.Add(m_GameObject, currentNode);
                            }
                            parentNode.Nodes.Add(currentNode);

                            ProgressBarPerformStep();
                        }

                        if (fileNode.Nodes.Count > 0)
                        {
                            treeNodeCollection.Add(fileNode);
                        }
                    }
                }
            }
            tempDic.Clear();

            // build list of class strucutres
            if (buildClassStructures)
            {
                foreach (var assetsFile in assetsfileList)
                {
                    if (AllTypeMap.TryGetValue(assetsFile.unityVersion, out var curVer))
                    {
                        foreach (var type in assetsFile.m_Types.Where(x => x.m_Nodes != null))
                        {
                            var key = type.classID;
                            if (type.m_ScriptTypeIndex >= 0)
                            {
                                key = -1 - type.m_ScriptTypeIndex;
                            }
                            curVer[key] = new TypeTreeItem(key, type.m_Nodes);
                        }
                    }
                    else
                    {
                        var items = new SortedDictionary <int, TypeTreeItem>();
                        foreach (var type in assetsFile.m_Types.Where(x => x.m_Nodes != null))
                        {
                            var key = type.classID;
                            if (type.m_ScriptTypeIndex >= 0)
                            {
                                key = -1 - type.m_ScriptTypeIndex;
                            }
                            items.Add(key, new TypeTreeItem(key, type.m_Nodes));
                        }
                        AllTypeMap.Add(assetsFile.unityVersion, items);
                    }
                }
            }
        }