public static void UpdateLeoSystems()
{
var gameSystemAsset = AssetEditorTools.LoadOrCreate <LeoEcsSettingsAsset>(AssetPath);
var systems = GetAllSystems();
var data = gameSystemAsset.systemsData;
var systemsContainer = data.systems;
foreach (var ecsSystem in systems)
{
if (systemsContainer.Any(x => x.system?.GetType() == ecsSystem.GetType()))
{
continue;
}
var updateType = PlayerLoopTiming.Update;
var systemType = ecsSystem.GetType();
var updateTimingAttribute = systemType.GetCustomAttribute <UpdateTimingAttribute>();
updateType = updateTimingAttribute == null ? updateType : updateTimingAttribute.updateType;
systemsContainer.Add(new EcsSystemData()
{
system = ecsSystem,
systemData = new LeoSystemData()
{
updateType = updateType,
}
});
}
gameSystemAsset.MarkDirty();
AssetDatabase.Refresh();
}
public string CreateCloudBuildMethods()
{
var classTextAsset = ClassTemplate?.text;
var methodsTextAsset = MethodsTemplate?.text;
if (string.IsNullOrEmpty(classTextAsset))
{
Debug.LogWarning($"CreateCloudBuildClass: ERROR CLASS {ClassTemplatePath} NULL value");
return(string.Empty);
}
if (string.IsNullOrEmpty(methodsTextAsset))
{
Debug.LogWarning($"CreateCloudBuildMethods: ERROR METHODS {MethodsTemplatePath} NULL value");
return(string.Empty);
}
var commands = AssetEditorTools.GetAssets <UniBuildCommandsMap>();
var methodsValue = string.Empty;
foreach (var command in commands)
{
var guid = AssetEditorTools.GetGUID(command);
var methodValue = methodsTextAsset.Replace(ConfigGUIDKey, guid);
var methodName = command.name.RemoveSpecialAndDotsCharacters();
methodsValue += methodValue.Replace(BuildConfigKey, methodName);
}
return(classTextAsset.Replace(MethodsKey, methodsValue));
}
public void Refresh()
{
configurations.Clear();
var configs = AssetEditorTools.GetAssets <UniBuildCommandsMap>();
configurations.AddRange(configs);
}
public string CreateBuildMethod(UniBuildCommandsMap config)
{
var name = config.ItemName.RemoveSpecialAndDotsCharacters();
var id = AssetEditorTools.GetGUID(config);
var method = $"{string.Format(_menuTemplate,name)} public static void Build_{name}() => UniBuildTool.BuildByConfigurationId(\"{id}\");";
return(method);
}
static BuildConfigurationsPostProcessor()
{
AssemblyReloadEvents.afterAssemblyReload += () =>
{
var assets = AssetEditorTools.GetAssets <UniBuildCommandsMap>();
commandsMapPaths.Clear();
commandsMapPaths.AddRange(assets.Select(AssetDatabase.GetAssetPath));
};
}
public static void RefreshUiSettings()
{
var uiSettings = AssetEditorTools.GetAssets <ViewsSettings>();
foreach (var source in uiSettings)
{
Build(source);
}
}
// #if ODIN_INSPECTOR
// [Sirenix.OdinInspector.Button]
// [Sirenix.OdinInspector.GUIColor(0.5f, 0.8f, 0.2f)]
// #endif
public void Resize()
{
if (resultAssets.Count == 0)
{
Search();
}
AssetEditorTools.ShowProgress(TextureProgressAction(x => Resize(x)));
}
public static void Rebuild()
{
var settings = AssetEditorTools.GetAssets <ModelViewsModuleSettings>();
foreach (var setting in settings)
{
Rebuild(setting);
EditorUtility.SetDirty(setting);
}
}
public void RebuildViewSettings()
{
var viewSettings = AssetEditorTools.GetAssets <ViewsSettings>();
foreach (var setting in viewSettings)
{
Build(setting);
setting.MarkDirty();
}
}
public string[] GetBuildMethods()
{
var map = new List <string>();
var commands = AssetEditorTools.GetAssets <UniBuildCommandsMap>();
foreach (var command in commands)
{
map.Add(CreateBuildMethod(command));
}
return(map.ToArray());
}
public SerializableNodeContainer Initialize(SerializableNode target, NodeGraph graphData)
{
node = target;
graph = graphData;
var nodeType = node?.GetType();
type = node?.GetType().Name;
script = AssetEditorTools.GetScriptAsset(nodeType);
fullType = node?.GetType().AssemblyQualifiedName;
return(this);
}
protected override void OnEnable()
{
base.OnEnable();
infoView = AssetEditorTools.GetAsset <AssetInfoEditorAsset>();
if (infoView)
{
return;
}
infoView = ScriptableObject.CreateInstance <AssetInfoEditorAsset>();
infoView.SaveAsset(nameof(AssetInfoEditorAsset), DefaultEditorToolPath);
}
private static void SetFastModeToManagers(bool isFastMode)
{
var atlasManagers = AssetEditorTools.GetAssets <AddressableSpriteAtlasConfiguration>();
foreach (var manager in atlasManagers)
{
manager.isFastMode = isFastMode;
manager.MarkDirty();
GameLog.Log($"Set fast mode [{isFastMode}] to {manager.name}");
}
}
private List <TView> LoadUiViews <TView>(IReadOnlyList <string> paths)
where TView : class, IView
{
var assets = AssetEditorTools.GetAssets <GameObject>(paths.ToArray());
var views = assets
.Select(x => x.GetComponent <TView>())
.Where(x => x != null)
.Where(x => !proceedViews.Contains(x)).ToList();
return(views);
}
private void UpdateSearchResults()
{
ClearResults();
_filterTypes.Clear();
var assetType = objectTypeFilter is MonoScript scriptObject?
scriptObject.GetClass() :
objectTypeFilter?.GetType();
assetType?.AddToCollection(_filterTypes);
var assets = AssetEditorTools.GetAssets <Object>(filter, folderFilter.ToArray());
if (singleTarget)
{
assets.Add(singleTarget);
}
//remove all filtered
assets.RemoveAll(x => FilterAsset(x) == false);
var searchData = new SearchData()
{
assets = assets.ToArray(),
regExFilters = ignoreFilter.
Concat(ignoreFolders).
Select(EditorFileUtils.FixUnityPath).
ToArray(),
fileTypes = typeFilter.ToArray(),
};
var result = AssetReferenceFinder.FindReferences(searchData);
foreach (var reference in result.referenceMap)
{
var assetItem = reference.Key;
var referencesData = reference.Value.
Select(x => x.asset).
ToList();
var referenceData = new ReferencesInfoData()
{
source = assetItem.ToEditorResource(),
references = referencesData
};
_referencesData.Add(referenceData);
}
FilterReferences();
}
public void ApplyImportSettings()
{
try
{
AssetDatabase.StartAssetEditing();
AssetEditorTools.ShowProgress(TextureProgressAction(x => Import(x)));
}
finally
{
AssetDatabase.StopAssetEditing();
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public static GoogleSpreadsheetImporter GetGoogleSpreadsheetImporter()
{
//load importer asset
var importer = AssetEditorTools.GetAsset <GoogleSpreadsheetImporter>();
if (importer)
{
return(importer);
}
importer = CreateInstance <GoogleSpreadsheetImporter>();
importer.SaveAsset(nameof(GoogleSpreadsheetImporter), GoogleSheetImporterEditorConstants.DefaultGoogleSheetImporterPath);
return(importer);
}
public static void Reimport()
{
var atlases = AssetEditorTools.GetAssets <SpriteAtlas>();
var addressableAtlases = atlases.
Where(x => x.IsInAnyAddressableAssetGroup()).
Select(x => new AssetReferenceSpriteAtlas(AssetEditorTools.GetGUID(x))).
ToList();
var atlasManagers = AssetEditorTools.GetAssets <AddressableSpriteAtlasConfiguration>();
foreach (var manager in atlasManagers)
{
SetupMap(manager, addressableAtlases);
manager.MarkDirty();
}
}
public override IEnumerable <object> Load()
{
var attributeAssets = AssetEditorTools.
GetAssetsWithAttribute <ScriptableObject, SpreadsheetTargetAttribute>();
assets = attributeAssets.
Select(x => new SheetSyncItem()
{
asset = x.Value,
sheetId = x.Attribute == null || x.Attribute.UseTypeName ?
x.Value.GetType().Name :
x.Attribute.SheetName
}).
ToList();
return(assets.
OfType <object>().
ToList());
}
public static void CreateGraph()
{
var graph = new GameObject().AddComponent <UniGraph>();
graph.SetName(graph.name);
//add main root node
var root = graph.AddNode <UniPortNode>(DefaultInputNodeName);
root.name = DefaultInputNodeName;
root.direction = PortIO.Input;
var activePath = AssetDatabase.GetAssetPath(Selection.activeObject);
var assetFolder = Directory.Exists(activePath) ? activePath :
Path.GetDirectoryName(activePath);
AssetEditorTools.SaveAsset(graph.gameObject, DefaultGraphName, assetFolder);
}
public string CreateCloudBuildMethods()
{
var methodsTextAsset = LoadMethodsTemplate();
var commands = AssetEditorTools.GetAssets <UniBuildCommandsMap>();
var methodsValue = string.Empty;
foreach (var command in commands)
{
var guid = AssetEditorTools.GetGUID(command);
var methodValue = methodsTextAsset.Replace(ConfigGUIDKey, guid);
var methodName = command.name.RemoveSpecialAndDotsCharacters();
methodsValue += methodValue.Replace(BuildConfigKey, methodName);
}
var classTextAsset = ClassTemplate.Replace(ClassNameTemplate, ClassName);
return(classTextAsset.Replace(MethodsKey, methodsValue));
}
public IUniBuildCommandsMap SelectActualBuildMap(IUniBuilderConfiguration configuration)
{
//load build command maps
var commandsMapsResources = AssetEditorTools.
GetEditorResources <UniBuildCommandsMap>();
//filter all valid commands map
foreach (var mapResource in commandsMapsResources)
{
var commandMap = mapResource.Load <IUniBuildCommandsMap>();
if (!commandMap.Validate(configuration))
{
continue;
}
LogBuildStep($"SELECT BUILD MAP {commandMap.ItemName}");
return(commandMap);
}
return(null);
}
private void UpdateSearchResults()
{
ClearSearch();
var folderFilters = searchFolders.Where(x => !string.IsNullOrEmpty(x)).ToArray();
if (folderFilters.Length > 0)
{
var importers = Filter(AssetEditorTools.GetAssetImporters <Object>(folderFilters));
resultAssets.AddRange(importers);
}
var result = Filter(targetAssets.Where(x => x).
Select(AssetEditorTools.GetAssetImporter)).
ToList();
var assetsPaths = new HashSet <string>();
resultAssets.AddRange(result);
resultAssets = resultAssets.
Where(x => assetsPaths.Add(x.assetPath)).
ToList();
}
/// <summary>
/// Sync folder assets by spreadsheet data
/// </summary>
/// <param name="filterType"></param>
/// <param name="folder"></param>
/// <param name="createMissing">if true - create missing assets</param>
/// <param name="spreadsheetData"></param>
/// <param name="maxItems"></param>
/// <param name="overrideSheetId"></param>
/// <returns></returns>
public List <Object> SyncFolderAssets(
Type filterType,
string folder,
bool createMissing,
ISpreadsheetData spreadsheetData,
int maxItems = -1,
string overrideSheetId = "")
{
if (!filterType.IsScriptableObject() && !filterType.IsComponent())
{
Debug.LogError($"SyncFolderAssets: BAD target type {filterType}");
return(null);
}
var assets = AssetEditorTools.GetAssets <Object>(filterType, folder);
var result = SyncFolderAssets(
filterType,
folder,
spreadsheetData,
assets.ToArray(),
createMissing, maxItems, overrideSheetId);
return(result);
}
private void UpdateView()
{
foreach (var drawer in UiElementFactory.Drawers)
{
var type = drawer.GetType();
_drawers.Add(new DrawerItemInfo()
{
type = type,
name = type.Name,
source = AssetEditorTools.GetScriptAsset(type),
});
}
foreach (var drawer in UiElementFactory.FieldDrawers)
{
var type = drawer.GetType();
_drawers.Add(new DrawerItemInfo()
{
type = type,
name = type.Name,
source = AssetEditorTools.GetScriptAsset(type),
});
}
}
public List <ViewFlowControllerAsset> GetFlowTypes()
{
return(AssetEditorTools.GetAssets <ViewFlowControllerAsset>());
}
public void Initialize()
{
_mapInfos = AssetEditorTools.GetAssets <CellItemsMapInfo>();
}
public IEnumerable <TUnityCommand> GetPostBuildCommands()
{
return(AssetEditorTools.GetAssets <TUnityCommand>());
}
public static List <Object> GetAssetsByType(Type baseType)
{
var result = AssetEditorTools.GetAssets <Object>(baseType);
return(result);
}
public IEnumerable <Object> ApplyAssets(
Type filterType,
string sheetId,
string folder,
SheetSyncScheme syncScheme,
ISpreadsheetData spreadsheetData,
object[] keys,
Object[] assets = null,
int count = -1,
bool createMissing = true,
string keyFieldName = "")
{
count = count < 0 ? keys.Length : count;
count = Math.Min(keys.Length, count);
var keyField = string.IsNullOrEmpty(keyFieldName) ? syncScheme.keyField : syncScheme.GetFieldBySheetFieldName(keyFieldName);
try {
for (var i = 0; i < count; i++)
{
var keyValue = keys[i];
var key = keyValue.TryConvert <string>();
var targetAsset = assets?.FirstOrDefault(x => string.Equals(keyField.GetValue(x).TryConvert <string>(),
key, StringComparison.OrdinalIgnoreCase));
//create asset if missing
if (targetAsset == null)
{
//skip asset creation step
if (createMissing == false)
{
continue;
}
targetAsset = filterType.CreateAsset();
targetAsset.SaveAsset($"{filterType.Name}_{i + 1}", folder, false);
Debug.Log($"Create Asset [{targetAsset}] for path {folder}", targetAsset);
}
//show assets progression
AssetEditorTools.ShowProgress(new ProgressData()
{
IsDone = false,
Progress = i / (float)count,
Content = $"{i}:{count} {targetAsset.name}",
Title = "Spreadsheet Importing"
});
var spreadsheetValueInfo = new SheetValueInfo()
{
Source = targetAsset,
SheetName = sheetId,
SpreadsheetData = spreadsheetData,
SyncScheme = syncScheme,
SyncFieldName = keyField.sheetField,
SyncFieldValue = keyValue,
};
ApplyData(spreadsheetValueInfo);
yield return(targetAsset);
}
}
finally {
AssetEditorTools.ShowProgress(new ProgressData()
{
IsDone = true,
});
AssetDatabase.SaveAssets();
}
}
