public bool Execute(ViewsSettings settings)
{
proceedViews.Clear();
previousReferences.Clear();
previousReferences.AddRange(settings.uiViews);
settings.uiViews.Clear();
var skinsFolders = settings.uiViewsSkinFolders;
var defaultFolders = settings.uiViewsDefaultFolders;
var groupName = string.IsNullOrEmpty(settings.sourceName)
? settings.name
: settings.sourceName;
if (skinsFolders.Count > 0)
{
var views = LoadUiViews <IView>(skinsFolders);
views.ForEach(x => AddView(settings, x, false, groupName));
}
if (defaultFolders.Count > 0)
{
var views = LoadUiViews <IView>(defaultFolders);
views.ForEach(x => AddView(settings, x, true, groupName));
}
settings.uiViews
.ForEach(ApplyOverrideValues);
previousReferences.Clear();
return(settings);
}
public static void Build(this ViewsSettings settings)
{
if (settings == null)
{
return;
}
settingsBuilder.Build(settings);
}
private static bool Validate(ViewsSettings settings, string[] paths)
{
var settingsTargets = GetSettingsPath(settings);
var changesViews = paths.
Any(x => settingsTargets.
Any(path => x.IndexOf(path, StringComparison.OrdinalIgnoreCase) >= 0));
return(changesViews);
}
private ViewsSettings ApplyViewSettingsPipeline(ViewsSettings settings)
{
foreach (var settingsCommand in rebuildSettingsCommands)
{
var result = settingsCommand.Execute(settings);
if (!result)
{
break;
}
}
return(settings);
}
public void Unregister(string filepath, IWpfTextView view)
{
Debug.Assert(views.ContainsKey(filepath));
ViewsSettings viewsSettings = views[filepath];
Debug.Assert(viewsSettings.Views.Contains(view));
viewsSettings.Views.Remove(view);
if (viewsSettings.Views.Count == 0)
{
views.Remove(filepath);
}
}
public void Register(string filepath, IWpfTextView view, FileSettings settings)
{
ViewsSettings viewsSettings;
if (!views.TryGetValue(filepath, out viewsSettings))
{
viewsSettings = new ViewsSettings(view, settings);
views.Add(filepath, viewsSettings);
}
else
{
Debug.Assert(!viewsSettings.Views.Contains(view));
viewsSettings.Views.Add(view);
}
}
public void Build(ViewsSettings settings)
{
addressableAssetSettings = AddressableAssetSettingsDefaultObject.Settings;
if (settings.isActive == false)
{
return;
}
if (!settings)
{
GameLog.LogError($"EMPTY UiManagerSettings on UiAssemblyBuilder.Build");
return;
}
ApplyViewSettingsPipeline(settings);
settings.MarkDirty();
}
private void AddView(ViewsSettings viewsSettings, IView view, bool defaultView, string groupName)
{
var assetView = view as MonoBehaviour;
if (assetView == null)
{
GameLog.LogError($"View at Path not Unity Asset with View Type {defaultView}");
return;
}
var gameObject = assetView.gameObject;
var guid = gameObject.GetGUID();
var views = viewsSettings.uiViews;
if (views.Any(x => string.Equals(guid, x.AssetGUID)))
{
return;
}
var assetPath = AssetDatabase.GetAssetPath(gameObject);
var tag = defaultView ? string.Empty : Path.GetFileName(Path.GetDirectoryName(assetPath));
var labels = viewsSettings.labels;
gameObject.SetAddressableAssetGroup(groupName);
var assetReference = gameObject.PrefabToAssetReference();
if (assetReference.RuntimeKeyIsValid() == false)
{
GameLog.LogError($"Asset {gameObject.name} by path {assetPath} wrong addressable asset");
return;
}
var viewDescription = new UiViewReference()
{
Tag = tag,
AssetGUID = assetReference.AssetGUID,
Type = view.GetType(),
View = assetReference,
ViewName = assetReference.editorAsset.name
};
views.Add(viewDescription);
}
private HashSet <ViewsSettings> GetSettings(ViewsSettings viewsSettings, HashSet <ViewsSettings> settings)
{
if (!settings.Add(viewsSettings))
{
return(settings);
}
if (!(viewsSettings is ViewSystemSettings systemSettings))
{
return(settings);
}
var nestedSettings = systemSettings.sources;
foreach (var nestedSetting in nestedSettings)
{
GetSettings(nestedSetting.viewSourceReference.editorAsset, settings);
}
return(settings);
}
public void Build(ViewsSettings settings)
{
addressableAssetSettings = AddressableAssetSettingsDefaultObject.Settings;
if (settings.isActive == false)
{
return;
}
proceedViews.Clear();
if (!settings)
{
GameLog.LogError($"EMPTY UiManagerSettings on UiAssemblyBuilder.Build");
return;
}
Reset(settings);
var skinsFolders = settings.uiViewsSkinFolders;
var defaultFolders = settings.uiViewsDefaultFolders;
var groupName = string.IsNullOrEmpty(settings.sourceName) ?
settings.name : settings.sourceName;
if (skinsFolders.Count > 0)
{
var views = LoadUiViews <IView>(skinsFolders);
views.ForEach(x => AddView(settings, x, false, groupName));
}
if (defaultFolders.Count > 0)
{
var views = LoadUiViews <IView>(defaultFolders);
views.ForEach(x => AddView(settings, x, true, groupName));
}
settings.MarkDirty();
}
private void AddView(ViewsSettings settings, IView view, bool defaultView, string groupName)
{
var views = settings.uiViews;
var assetView = view as MonoBehaviour;
if (assetView == null)
{
GameLog.LogError($"View at Path not Unity Asset with View Type {defaultView}");
return;
}
var gameObject = assetView.gameObject;
var guid = gameObject.GetGUID();
if (views.Any(x => string.Equals(guid, x.AssetGUID)))
{
return;
}
var viewReference = CreateViewReference(view, defaultView, settings.applyAddressablesGroup, groupName);
views.Add(viewReference);
}
public void Register(string filepath, IWpfTextView view, FileSettings settings)
{
ViewsSettings viewsSettings;
if (!views.TryGetValue(filepath, out viewsSettings))
{
viewsSettings = new ViewsSettings(view, settings);
views.Add(filepath, viewsSettings);
}
else
{
Debug.Assert(!viewsSettings.Views.Contains(view));
viewsSettings.Views.Add(view);
}
}
public bool Execute(ViewsSettings value)
{
return(true);
}
public static void Rebuild(ViewsSettings settings)
{
settings.Build();
settings.SetDirty();
GameLog.Log($"Rebuild Ui View Settings", Color.blue);
}
private static IEnumerable <string> GetSettingsPath(ViewsSettings settings)
{
return(settings.uiViewsDefaultFolders.
Concat(settings.uiViewsSkinFolders));
}
public void Reset(ViewsSettings settings)
{
settings.uiViews.Clear();
}
public bool Execute(ViewsSettings value)
{
return(value.IsActive);
}
protected override int ExecuteInternalWithExitCode()
{
var opts = this.Options;
var relativeProjectPath = "project/views.json";
var directory = opts.Directory;
if (string.IsNullOrWhiteSpace(directory))
{
directory = Environment.CurrentDirectory;
}
var settings = CompilerRunner.GetBuildSettings(directory, relativeProjectPath, new SharpJsonSerializer(), true);
var newViewSettings = new ViewsSettings();
IViewsSettings optsSettings = opts;
newViewSettings.Imports = optsSettings.Imports.Union(settings.Imports).ToArray();
newViewSettings.References = optsSettings.References.Union(settings.References)
.Select(x => new Reference {
HintPath = x.HintPath, Name = x.Name
})
.Distinct(DelegatedEqualityComparer.Builder <Reference>().Build(x => x.Name))
.ToArray();
newViewSettings.LinkerPath = Fold(opts, settings, x => x.LinkerPath);
newViewSettings.OutputFile = Fold(opts, settings, x => x.OutputFile);
newViewSettings.RelativeIntermediateDirectory = Fold(opts, settings, x => x.RelativeIntermediateDirectory);
newViewSettings.RelativeSourceDirectory = Fold(opts, settings, x => x.RelativeSourceDirectory);
newViewSettings.SecondaryOutputFile = Fold(opts, settings, x => x.SecondaryOutputFile);
newViewSettings.SkipSecondaryOutputFile = opts.SkipSecondaryOutputFile || settings.SkipSecondaryOutputFile;
if (opts.SingleRun)
{
var logFile = new StreamWriter(File.OpenWrite(Path.Combine(directory, "Logs", DateTime.Now.ToString("dd-MM-yyyy-hh-mm-ss"))));
var logger = opts.Verbose
? (ILogger) new TextWriterLogger(Console.Out)
: new NullLogger();
using (var compiler = CompilerRunner.StartWatching(directory, settings, new ConsoleMessenger(), logger))
{
if (compiler.Compile() == CompileResult.Success)
{
return(-1);
}
return(-2);
}
}
using (var executor = new SoufflotExecutor(directory, settings, new ConsoleMessenger(), opts.Port))
{
executor.Run();
}
return(0);
}
