public bool MoveToBottom(EditorStoryboardLayer layer)
{
var index = layers.IndexOf(layer);
if (index != -1)
{
if (index == layers.Count - 1)
{
return(false);
}
while (index < layers.Count - 1 && layer.CompareTo(layers[index + 1]) == 0)
{
var otherLayer = layers[index + 1];
layers[index + 1] = layer;
layers[index] = otherLayer;
++index;
}
}
else
{
throw new InvalidOperationException($"Cannot move layer '{layer.Name}'");
}
OnLayersChanged?.Invoke(this, EventArgs.Empty);
return(true);
}
public void Remove(EditorStoryboardLayer layer)
{
if (layers.Remove(layer))
{
layer.OnChanged -= layer_OnChanged;
OnLayersChanged?.Invoke(this, EventArgs.Empty);
}
}
public override StoryboardLayer GetLayer(string identifier)
{
var layer = EditorLayers.Find(l => l.Identifier == identifier);
if (layer == null)
{
EditorLayers.Add(layer = new EditorStoryboardLayer(identifier, effect));
}
return(layer);
}
public override void AddPlaceholder(EditorStoryboardLayer layer)
{
if (placeHolderLayer != null)
{
layers.Remove(placeHolderLayer);
Project.LayerManager.Remove(placeHolderLayer);
placeHolderLayer = null;
}
layers.Add(layer);
refreshLayerNames();
Project.LayerManager.Add(layer);
}
public void MoveToOsbLayer(EditorStoryboardLayer layer, OsbLayer osbLayer)
{
var firstLayer = layers.FirstOrDefault(l => l.OsbLayer == osbLayer);
if (firstLayer != null)
{
MoveToLayer(layer, firstLayer);
}
else
{
layer.OsbLayer = osbLayer;
}
}
public ScriptedEffect(Project project, ScriptContainer <StoryboardObjectGenerator> scriptContainer) : base(project)
{
statusStopwatch.Start();
this.scriptContainer = scriptContainer;
name = project.GetUniqueEffectName(BaseName);
layers = new List <EditorStoryboardLayer>();
layers.Add(placeHolderLayer = new EditorStoryboardLayer(string.Empty, this));
refreshLayerNames();
Project.LayerManager.Add(placeHolderLayer);
scriptContainer.OnScriptChanged += scriptContainer_OnScriptChanged;
}
private int findLayerIndex(EditorStoryboardLayer layer)
{
var index = layers.BinarySearch(layer);
if (index >= 0)
{
while (index < layers.Count && layer.CompareTo(layers[index]) == 0)
{
index++;
}
return(index);
}
else
{
return(~index);
}
}
public void Replace(EditorStoryboardLayer oldLayer, EditorStoryboardLayer newLayer)
{
var index = layers.IndexOf(oldLayer);
if (index != -1)
{
newLayer.CopySettings(oldLayer, copyGuid: true);
newLayer.OnChanged += layer_OnChanged;
oldLayer.OnChanged -= layer_OnChanged;
layers[index] = newLayer;
}
else
{
throw new InvalidOperationException($"Cannot replace layer '{oldLayer.Name}' with '{newLayer.Name}', old layer not found");
}
OnLayersChanged?.Invoke(this, EventArgs.Empty);
}
public void MoveToLayer(EditorStoryboardLayer layerToMove, EditorStoryboardLayer toLayer)
{
layerToMove.OsbLayer = toLayer.OsbLayer;
var fromIndex = layers.IndexOf(layerToMove);
var toIndex = layers.IndexOf(toLayer);
if (fromIndex != -1 && toIndex != -1)
{
layers.Move(fromIndex, toIndex);
sortLayer(layerToMove);
}
else
{
throw new InvalidOperationException($"Cannot move layer '{layerToMove.Name}' to the position of '{layerToMove.Name}'");
}
}
public void Replace(EditorStoryboardLayer oldLayer, List <EditorStoryboardLayer> newLayers)
{
var index = layers.IndexOf(oldLayer);
if (index != -1)
{
foreach (var newLayer in newLayers)
{
newLayer.CopySettings(oldLayer, copyGuid: false);
newLayer.OnChanged += layer_OnChanged;
}
layers.InsertRange(index, newLayers);
oldLayer.OnChanged -= layer_OnChanged;
layers.Remove(oldLayer);
}
else
{
throw new InvalidOperationException($"Cannot replace layer '{oldLayer.Name}' with multiple layers, old layer not found");
}
OnLayersChanged?.Invoke(this, EventArgs.Empty);
}
private void sortLayer(EditorStoryboardLayer layer)
{
var initialIndex = layers.IndexOf(layer);
if (initialIndex < 0)
{
new InvalidOperationException($"Layer '{layer.Name}' cannot be found");
}
var newIndex = initialIndex;
while (newIndex > 0 && layer.CompareTo(layers[newIndex - 1]) < 0)
{
newIndex--;
}
while (newIndex < layers.Count - 1 && layer.CompareTo(layers[newIndex + 1]) > 0)
{
newIndex++;
}
layers.Move(initialIndex, newIndex);
OnLayersChanged?.Invoke(this, EventArgs.Empty);
}
/// <summary> /// Used at load time to let the effect know about placeholder layers it should use. /// </summary> public abstract void AddPlaceholder(EditorStoryboardLayer layer);
/// <summary>
/// Should only be called by Project.QueueEffectUpdate(Effect).
/// Doesn't run on the main thread.
/// </summary>
public override void Update()
{
if (!scriptContainer.HasScript)
{
return;
}
var newDependencyWatcher = new MultiFileWatcher();
newDependencyWatcher.OnFileChanged += (sender, e) =>
{
if (IsDisposed)
{
return;
}
Refresh();
};
var context = new EditorGeneratorContext(this, Project.ProjectFolderPath, Project.MapsetPath, Project.MainBeatmap, Project.MapsetManager.Beatmaps, newDependencyWatcher);
var success = false;
try
{
changeStatus(EffectStatus.Loading);
var script = scriptContainer.CreateScript();
changeStatus(EffectStatus.Configuring);
Program.RunMainThread(() =>
{
beatmapDependant = true;
if (script.Identifier != configScriptIdentifier)
{
script.UpdateConfiguration(Config);
configScriptIdentifier = script.Identifier;
RaiseConfigFieldsChanged();
}
else
{
script.ApplyConfiguration(Config);
}
});
changeStatus(EffectStatus.Updating);
script.Generate(context);
foreach (var layer in context.EditorLayers)
{
layer.PostProcess();
}
success = true;
}
catch (RemotingException e)
{
Debug.Print($"Script execution failed with RemotingException, reloading {BaseName} ({e.Message})");
changeStatus(EffectStatus.ReloadPending);
Program.Schedule(() =>
{
if (Project.IsDisposed)
{
return;
}
scriptContainer.ReloadScript();
});
return;
}
catch (ScriptCompilationException e)
{
Debug.Print($"Script compilation failed for {BaseName}\n{e.Message}");
changeStatus(EffectStatus.CompilationFailed, e.Message, context.Log);
return;
}
catch (ScriptLoadingException e)
{
Debug.Print($"Script load failed for {BaseName}\n{e.ToString()}");
changeStatus(EffectStatus.LoadingFailed, e.InnerException != null ? $"{e.Message}: {e.InnerException.Message}" : e.Message, context.Log);
return;
}
catch (Exception e)
{
changeStatus(EffectStatus.ExecutionFailed, getExecutionFailedMessage(e), context.Log);
return;
}
finally
{
if (!success)
{
if (dependencyWatcher != null)
{
dependencyWatcher.Watch(newDependencyWatcher.WatchedFilenames);
newDependencyWatcher.Dispose();
newDependencyWatcher = null;
}
else
{
dependencyWatcher = newDependencyWatcher;
}
}
context.DisposeResources();
}
changeStatus(EffectStatus.Ready, null, context.Log);
Program.Schedule(() =>
{
if (IsDisposed)
{
newDependencyWatcher.Dispose();
return;
}
beatmapDependant = context.BeatmapDependent;
dependencyWatcher?.Dispose();
dependencyWatcher = newDependencyWatcher;
if (Project.IsDisposed)
{
return;
}
if (placeHolderLayer != null)
{
Project.LayerManager.Replace(placeHolderLayer, context.EditorLayers);
placeHolderLayer = null;
}
else
{
Project.LayerManager.Replace(layers, context.EditorLayers);
}
layers = context.EditorLayers;
refreshLayerNames();
refreshEstimatedSize();
});
}
public void Add(EditorStoryboardLayer layer)
{
layers.Insert(findLayerIndex(layer), layer);
layer.OnChanged += layer_OnChanged;
OnLayersChanged?.Invoke(this, EventArgs.Empty);
}
