Studio/Assets/Scripts/Studio/Managers/AssetManager.cs

using Studio.AssetTool;
using Studio.Command;
using Studio.HierarchyTree;
using Studio.Services;
using Studio.Util;
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace Studio.Manage
{
    public class AssetManager : Manager
    {
        public List<string> localAssetPaths = new List<string>();

        private List<string> folderPathList = new List<string>();
        private Dictionary<int, HierarchyItem> itemDict = new Dictionary<int, HierarchyItem>();

        private Dictionary<int, string> assetSettingPaths = new Dictionary<int, string>();
        public Action<Dictionary<int, string>> onAddSettingPaths;

        public Action<AssetManagerData> onAssetManagerDatas;
        public Action<AssetManagerData> onSetAssetManager;
        public Action<AssetManagerData> onSetAssetSetting;

        public override void Init()
        {
            folderPathList.Clear();

            var canvas_Popup = CanvasManager.instance.GetCanvas<Canvas_Popup>();
            var fbxFileManager = ManagerHub.instance.Get<FBXFileManager>();
            var connector = ManagerHub.instance.Get<CustomAssetConnector>();
            var sceneSettingService = ManagerHub.instance.Get<SceneStartSettingManager>();
            var projectManager = ManagerHub.instance.Get<ProjectManager>();
            fbxFileManager.onLoadComplete += OnLoadCustomAsset;
            onAddSettingPaths += canvas_Popup.panel_assetsetting.SetAssetPathItmes;
            onSetAssetSetting += canvas_Popup.panel_assetsetting.SetAssetManager;

            onAssetManagerDatas += (data) => projectManager.OpenProjectSettingsDataAfterDataLoad();

        }

        public void ClearFolderPathList()
        {
            localAssetPaths.Clear();
            folderPathList.Clear();
        }
        public void LoadAssetSettingFBXDirectorys(int index, string folderPath)
        {
            if (!assetSettingPaths.ContainsKey(index))
            {
                assetSettingPaths.Add(index, folderPath);
            }
            else
            {
                assetSettingPaths[index] = folderPath;
            }
            onAddSettingPaths?.Invoke(assetSettingPaths);
            CombineAssetFolderPaths(assetSettingPaths.Values.ToList());
        }

        public void CombineAssetFolderPaths(List<string> folderPaths)
        {
            ClearFolderPathList();
            InitRessourceAsset();

            if (folderPaths == null)
                return;

            foreach (var folderPath in folderPaths)
            {
                if (folderPathList.Contains(folderPath))
                {
                    continue;
                }
                folderPathList.Add(folderPath);
                localAssetPaths.Add(folderPath);
            }

            LoadLocalFBXDirectorys();
        }

        public void InitRessourceAsset()
        {
            var assets = Resources.LoadAll<GameObject>("Sample");
            var fbxFileManager = ManagerHub.instance.Get<FBXFileManager>();
            fbxFileManager.LoadResource(assets);
        }


        public void LoadLocalFBXDirectorys()
        {
            var fbxFileManager = ManagerHub.instance.Get<FBXFileManager>();
            fbxFileManager.LoadLocalFBXDirectorys(folderPathList);

            var assetManagerData = new AssetManagerData();
            assetManagerData.localAssetsPaths.AddRange(folderPathList);
            onAssetManagerDatas?.Invoke(assetManagerData);
        }
        public void SetAssetManager(AssetManagerData data)
        {
            onSetAssetSetting?.Invoke(data);
        }

        private void OnLoadCustomAsset()
        {
            var projectManager = ManagerHub.instance.Get<ProjectManager>();
            var fbxFileManager = ManagerHub.instance.Get<FBXFileManager>();

            if (projectManager.curProjectData.assetDatas.Count <= 0)
                return;

            List<AssetData> assets = projectManager.curProjectData.assetDatas;

            CommandInvoker.instance.Invoke(new RemoveAllObjectCommand());

            foreach (AssetData asset in assets)
            {
                LoadAsset(asset);
            }

            foreach (AssetData asset in assets)
            {
                RestoreHierarchy(asset);
            }

            onAssetManagerDatas?.Invoke(projectManager.curProjectData.assetManagerData);

        }
        private void LoadAsset(AssetData asset)
        {
            var connector = ManagerHub.instance.Get<CustomAssetConnector>();
            connector.OnLoadAsset(asset);
        }

        private void RestoreHierarchy(AssetData asset)
        {
            var connector = ManagerHub.instance.Get<CustomAssetConnector>();
            itemDict.TryAdd(asset.id, connector.connectedAssets.Last().hierarchyItem);

            foreach (int id in asset.children)
            {
                HierarchyItem parent = itemDict[asset.id];
                HierarchyItem child = itemDict[id];

                if (parent == null || child == null)
                    continue;

                connector.OnRestoreHierarchy(parent, child);
            }
        }
    }
}