示例#1
0
    static ImportSettingData()
    {
        // 加载配置文件
        Setting = AssetDatabase.LoadAssetAtPath <ImportSetting>(EditorDefine.ImporterSettingFilePath);
        if (Setting == null)
        {
            Debug.LogWarning($"Create new ImportSetting.asset : {EditorDefine.ImporterSettingFilePath}");
            Setting = ScriptableObject.CreateInstance <ImportSetting>();
            EditorTools.CreateFileDirectory(EditorDefine.ImporterSettingFilePath);
            AssetDatabase.CreateAsset(Setting, EditorDefine.ImporterSettingFilePath);
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
        }
        else
        {
            Debug.Log("Load ImportSetting.asset ok");
        }

        // Clear
        CacheTypes.Clear();
        CacheProcessor.Clear();

        // 获取所有资源处理器类型
        List <Type> result = AssemblyUtility.GetAssignableTypes(typeof(IAssetProcessor));

        for (int i = 0; i < result.Count; i++)
        {
            Type type = result[i];
            if (CacheTypes.ContainsKey(type.Name) == false)
            {
                CacheTypes.Add(type.Name, type);
            }
        }
    }
示例#2
0
        /// <summary>
        /// 加载配置文件
        /// </summary>
        private static void LoadSettingData()
        {
            // 加载配置文件
            _setting = AssetDatabase.LoadAssetAtPath <AssetImporterSetting>(EditorDefine.AssetImporterSettingFilePath);
            if (_setting == null)
            {
                Debug.LogWarning($"Create new {nameof(AssetImporterSetting)}.asset : {EditorDefine.AssetImporterSettingFilePath}");
                _setting = ScriptableObject.CreateInstance <AssetImporterSetting>();
                EditorTools.CreateFileDirectory(EditorDefine.AssetImporterSettingFilePath);
                AssetDatabase.CreateAsset(Setting, EditorDefine.AssetImporterSettingFilePath);
                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();
            }
            else
            {
                Debug.Log($"Load {nameof(AssetImporterSetting)}.asset ok");
            }

            // 清空缓存集合
            _cacheTypes.Clear();
            _cacheProcessor.Clear();

            // 获取所有资源处理器类型
            List <Type> types = AssemblyUtility.GetAssignableTypes(AssemblyUtility.UnityDefaultAssemblyEditorName, typeof(IAssetProcessor));

            types.Add(typeof(DefaultProcessor));
            for (int i = 0; i < types.Count; i++)
            {
                Type type = types[i];
                if (_cacheTypes.ContainsKey(type.Name) == false)
                {
                    _cacheTypes.Add(type.Name, type);
                }
            }
        }
        private void InitAssetEncrypter()
        {
            var types = AssemblyUtility.GetAssignableTypes(AssemblyUtility.UnityDefaultAssemblyEditorName, typeof(IAssetEncrypter));

            if (types.Count == 0)
            {
                return;
            }
            if (types.Count != 1)
            {
                throw new Exception($"Found more {nameof(IAssetEncrypter)} types. We only support one.");
            }

            BuildLogger.Log($"创建加密类 : {types[0].FullName}");
            _encrypter = (IAssetEncrypter)Activator.CreateInstance(types[0]);
        }
示例#4
0
        /// <summary>
        /// 加载配置文件
        /// </summary>
        private static void LoadSettingData()
        {
            // 加载配置文件
            _setting = AssetDatabase.LoadAssetAtPath <AssetBundleCollectorSetting>(EditorDefine.AssetBundleCollectorSettingFilePath);
            if (_setting == null)
            {
                Debug.LogWarning($"Create new {nameof(AssetBundleCollectorSetting)}.asset : {EditorDefine.AssetBundleCollectorSettingFilePath}");
                _setting = ScriptableObject.CreateInstance <AssetBundleCollectorSetting>();
                EditorTools.CreateFileDirectory(EditorDefine.AssetBundleCollectorSettingFilePath);
                AssetDatabase.CreateAsset(Setting, EditorDefine.AssetBundleCollectorSettingFilePath);
                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();
            }
            else
            {
                Debug.Log($"Load {nameof(AssetBundleCollectorSetting)}.asset ok");
            }

            // 收集器类型
            {
                // 清空缓存集合
                _cacheLabelTypes.Clear();
                _cacheLabelInstance.Clear();

                // 获取所有类型
                List <Type> types = new List <Type>(100)
                {
                    typeof(LabelByFilePath),
                    typeof(LabelByFolderPath)
                };
                var customTypes = AssemblyUtility.GetAssignableTypes(AssemblyUtility.UnityDefaultAssemblyEditorName, typeof(IBundleLabel));
                types.AddRange(customTypes);
                for (int i = 0; i < types.Count; i++)
                {
                    Type type = types[i];
                    if (_cacheLabelTypes.ContainsKey(type.Name) == false)
                    {
                        _cacheLabelTypes.Add(type.Name, type);
                    }
                }
            }

            // 过滤器类型
            {
                // 清空缓存集合
                _cacheFilterTypes.Clear();
                _cacheFilterInstance.Clear();

                // 获取所有类型
                List <Type> types = new List <Type>(100)
                {
                    typeof(SearchAll),
                    typeof(SearchScene),
                    typeof(SearchPrefab),
                    typeof(SearchSprite)
                };
                var customTypes = AssemblyUtility.GetAssignableTypes(AssemblyUtility.UnityDefaultAssemblyEditorName, typeof(ISearchFilter));
                types.AddRange(customTypes);
                for (int i = 0; i < types.Count; i++)
                {
                    Type type = types[i];
                    if (_cacheFilterTypes.ContainsKey(type.Name) == false)
                    {
                        _cacheFilterTypes.Add(type.Name, type);
                    }
                }
            }
        }