public void LoadFramesFromAsset(ImageSequence asset)
{
inputSequence.frames.Clear();
if (asset.inputFrameGUIDs != null && asset.inputFrameGUIDs.Count > 0)
{
int count = asset.inputFrameGUIDs.Count;
int i = 1;
foreach (string guid in asset.inputFrameGUIDs)
{
VFXToolboxGUIUtility.DisplayProgressBar("Image Sequencer", "Loading Textures (" + i + "/" + count + ")", (float)i / count, 0.1f);
string path = AssetDatabase.GUIDToAssetPath(guid);
Texture2D t = AssetDatabase.LoadAssetAtPath <Texture2D>(path);
if (t != null)
{
inputSequence.frames.Add(new ProcessingFrame(t));
}
else
{
inputSequence.frames.Add(ProcessingFrame.Missing);
}
i++;
}
VFXToolboxGUIUtility.ClearProgressBar();
}
}
public void RemoveProcessor(int index, ImageSequence asset)
{
asset.processorInfos.RemoveAt(index);
m_Processors.RemoveAt(index);
EditorUtility.SetDirty(asset);
}
public void RemoveAllProcessors(ImageSequence asset)
{
asset.processorInfos.Clear();
m_Processors.Clear();
EditorUtility.SetDirty(asset);
}
public void ReorderProcessors(ImageSequence asset)
{
if (m_Processors.Count > 0)
{
List <FrameProcessor> old = new List <FrameProcessor>();
foreach (FrameProcessor p in m_Processors)
{
old.Add(p);
}
m_Processors.Clear();
foreach (ProcessorInfo info in asset.processorInfos)
{
foreach (FrameProcessor p in old)
{
if (p.ProcessorInfo.Equals(info))
{
m_Processors.Add(p);
break;
}
}
}
EditorUtility.SetDirty(asset);
}
}
public void RemoveAllInputFrames(ImageSequence asset)
{
asset.inputFrameGUIDs.Clear();
m_InputSequence.frames.Clear();
EditorUtility.SetDirty(asset);
}
public void RemoveProcessor(int index, ImageSequence asset)
{
asset.processorInfos.RemoveAt(index);
m_Processors.RemoveAt(index);
EditorUtility.SetDirty(asset);
UnityEditor.AssetDatabase.SaveAssets();
}
public void RemoveAllProcessors(ImageSequence asset)
{
asset.processorInfos.Clear();
m_Processors.Clear();
EditorUtility.SetDirty(asset);
UnityEditor.AssetDatabase.SaveAssets();
}
public void SortAllInputFrames(ImageSequence asset)
{
asset.inputFrameGUIDs.Sort((guidA, guidB) => {
return(string.Compare(AssetDatabase.GUIDToAssetPath(guidA), AssetDatabase.GUIDToAssetPath(guidB)));
});
EditorUtility.SetDirty(asset);
}
internal static ImageSequence CreateVFXToolboxAssetAtPath(string path)
{
ImageSequence asset = ScriptableObject.CreateInstance <ImageSequence>();
asset.name = Path.GetFileName(path);
AssetDatabase.CreateAsset(asset, path);
return(asset);
}
public void SyncFramesToAsset(ImageSequence asset)
{
asset.inputFrameGUIDs.Clear();
foreach (ProcessingFrame f in inputSequence.frames)
{
asset.inputFrameGUIDs.Add(AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(f.texture)));
}
EditorUtility.SetDirty(asset);
}
public void RemoveAllInputFrames(ImageSequence asset)
{
Undo.RecordObject(asset, "Remove All Frames");
asset.inputFrameGUIDs.Clear();
m_InputSequence.frames.Clear();
EditorUtility.SetDirty(asset);
UnityEditor.AssetDatabase.SaveAssets();
}
public void AddProcessor(FrameProcessor processor, ImageSequence asset)
{
AddProcessorInfoObjectToAsset(asset, processor.ProcessorInfo);
asset.processorInfos.Add(processor.ProcessorInfo);
ProcessorSettingsBase settings = processor.GetSettingsAbstract();
if (settings != null)
{
AddSettingsObjectToAsset(asset, settings);
processor.ProcessorInfo.Settings = settings;
}
m_Processors.Add(processor);
EditorUtility.SetDirty(asset);
}
public static bool OpenImageSequenceAsset(int instanceID, int line)
{
ImageSequence asset = EditorUtility.InstanceIDToObject(instanceID) as ImageSequence;
if (asset != null) // We opened an image sequence asset, open the editor.
{
ImageSequencer.OpenEditor();
ImageSequencer window = EditorWindow.GetWindow <ImageSequencer>();
window.Focus();
return(true);
}
else
{
return(false);
}
}
public void LoadProcessorsFromAsset(ImageSequence asset)
{
m_Processors.Clear();
var infos = asset.processorInfos;
UpdateProcessorsFromAssembly();
// Creating Runtime
foreach (ProcessorInfo procInfo in infos)
{
Type processorType = settingsDefinitions[procInfo.Settings.GetType()].processorType;
var processor = (FrameProcessor)Activator.CreateInstance(processorType, this, procInfo);
m_Processors.Add(processor);
}
}
private ImageSequence FindSettingsReference(ImageSequence asset, ref List <ImageSequence> dependencyList)
{
if (asset.inheritSettingsReference != null)
{
if (dependencyList.Contains(asset.inheritSettingsReference))
{
return(null);
}
dependencyList.Add(asset.inheritSettingsReference);
return(FindSettingsReference(asset.inheritSettingsReference, ref dependencyList));
}
else
{
return(asset);
}
}
internal ProcessorDataProvider(FrameProcessorStack stack, ImageSequence asset)
{
m_dataSource = stack.settingsDefinitions;
m_processorStack = stack;
m_CurrentAsset = asset;
}
public abstract bool OnSidePanelGUI(ImageSequence asset, int ProcessorIndex);
public void AddSettingsObjectToAsset(ImageSequence asset, ScriptableObject settings)
{
AssetDatabase.AddObjectToAsset(settings, asset);
settings.hideFlags = HideFlags.HideInHierarchy;
}
public void LoadAsset(ImageSequence asset)
{
m_CurrentAsset = asset;
m_InputFramesReorderableList = null;
m_ProcessorsReorderableList = null;
m_LockedPreviewProcessor = null;
m_CurrentProcessor = null;
// Free resources if any
if (m_processorStack != null)
{
m_processorStack.Dispose();
}
InitializeGUI();
if (m_CurrentAsset != null)
{
m_processorStack = new FrameProcessorStack(new ProcessingFrameSequence(null), this);
m_CurrentAssetSerializedObject = new SerializedObject(m_CurrentAsset);
VFXToolboxGUIUtility.DisplayProgressBar("Image Sequencer", "Loading asset....", 0.0f);
m_LockedPreviewProcessor = null;
VFXToolboxGUIUtility.DisplayProgressBar("Image Sequencer", "Loading Frames", 0.333333f);
m_processorStack.LoadFramesFromAsset(m_CurrentAsset);
UpdateInputTexturesHash();
m_InputFramesReorderableList = new ReorderableList(m_processorStack.inputSequence.frames, typeof(Texture2D), true, false, true, true);
m_InputFramesReorderableList.onAddCallback = AddInputFrame;
m_InputFramesReorderableList.onRemoveCallback = RemoveInputFrame;
m_InputFramesReorderableList.onReorderCallback = ReorderInputFrame;
m_InputFramesReorderableList.drawElementCallback = DrawInputFrameRListElement;
m_InputFramesReorderableList.onSelectCallback = SelectInputFrameRListElement;
VFXToolboxGUIUtility.DisplayProgressBar("Image Sequencer", "Loading Processors", 0.66666f);
ImageSequence inheritedSettingReference = m_CurrentAsset;
// Loading other settings if inheriting settings
if (m_CurrentAsset.inheritSettingsReference != null)
{
var dependencyList = new List <ImageSequence>();
var referenceAsset = FindSettingsReference(m_CurrentAsset.inheritSettingsReference, ref dependencyList);
if (referenceAsset == null)
{
Debug.LogWarning("Dependency Loop detected, ignoring using external settings");
m_IgnoreInheritSettings = true;
}
else
{
inheritedSettingReference = referenceAsset;
m_IgnoreInheritSettings = false;
}
}
m_processorStack.LoadProcessorsFromAsset(inheritedSettingReference);
m_ProcessorDataProvider = new ProcessorDataProvider(m_processorStack, m_CurrentAsset);
// Construct the RList
if (m_CurrentAsset.inheritSettingsReference == null)
{
m_ProcessorsReorderableList = new ReorderableList(m_CurrentAssetSerializedObject, m_CurrentAssetSerializedObject.FindProperty("processorInfos"), true, false, true, true);
m_ProcessorsReorderableList.onAddCallback = ShowAddProcessorMenu;
m_ProcessorsReorderableList.onRemoveCallback = MenuRemoveProcessor;
m_ProcessorsReorderableList.onReorderCallback = ReorderProcessor;
m_ProcessorsReorderableList.onSelectCallback = MenuSelectProcessor;
m_ProcessorsReorderableList.drawElementCallback = DrawRListProcessorElement;
m_SettingsReferenceSerializedObject = null;
}
else
{
m_SettingsReferenceSerializedObject = new SerializedObject(inheritedSettingReference);
m_ProcessorsReorderableList = new ReorderableList(m_SettingsReferenceSerializedObject, m_SettingsReferenceSerializedObject.FindProperty("processorInfos"), false, false, false, false);
m_ProcessorsReorderableList.drawElementCallback = DrawRListPreviewProcessorElement;
m_ProcessorsReorderableList.onSelectCallback = MenuSelectProcessor;
}
m_PreviewCanvas.sequence = m_processorStack.inputSequence;
if (m_PreviewCanvas.sequence.length > 0)
{
m_PreviewCanvas.currentFrameIndex = 0;
}
else
{
m_PreviewCanvas.currentFrameIndex = -1;
}
VFXToolboxGUIUtility.DisplayProgressBar("Image Sequencer", "Finalizing...", 1.0f);
m_processorStack.InvalidateAll();
RestoreProcessorView();
EditorUtility.ClearProgressBar();
}
}
public void AddProcessorInfoObjectToAsset(ImageSequence asset, ProcessorInfo info)
{
AssetDatabase.AddObjectToAsset(info, asset);
info.hideFlags = HideFlags.HideInHierarchy;
}
public override void Action(int instanceId, string pathName, string resourceFile)
{
ImageSequence asset = ImageSequenceAssetFactory.CreateVFXToolboxAssetAtPath(pathName);
ProjectWindowUtil.ShowCreatedAsset(asset);
}
public void ReverseAllInputFrames(ImageSequence asset)
{
asset.inputFrameGUIDs.Reverse();
EditorUtility.SetDirty(asset);
}
private void DrawProcessorsPanelContent()
{
ImageSequence seq = (ImageSequence)EditorGUILayout.ObjectField(VFXToolboxGUIUtility.Get("Inherit processors from"), m_CurrentAsset.inheritSettingsReference, typeof(ImageSequence), false);
if (m_IgnoreInheritSettings)
{
EditorGUILayout.HelpBox("Warning : Dependency Loop found when inheriting these settings, ignoring...", MessageType.Warning);
}
if (seq != m_CurrentAsset.inheritSettingsReference && m_CurrentAsset != seq)
{
Undo.RecordObject(m_CurrentAsset, "use processor settings from other ImageSequence");
m_CurrentAsset.inheritSettingsReference = seq;
if (seq != null)
{
m_CurrentAsset.editSettings.selectedProcessor = seq.editSettings.selectedProcessor;
m_CurrentAsset.editSettings.lockedProcessor = -1;
}
EditorUtility.SetDirty(m_CurrentAsset);
LoadAsset(m_CurrentAsset);
}
GUILayout.Space(10);
using (new EditorGUI.DisabledScope(m_CurrentAsset.inheritSettingsReference != null))
{
using (new EditorGUILayout.HorizontalScope())
{
GUILayout.Label(VFXToolboxGUIUtility.Get("Frame Processor Stack"), EditorStyles.boldLabel, GUILayout.Width(180));
GUILayout.FlexibleSpace();
if (GUILayout.Button(VFXToolboxGUIUtility.Get("Clear"), GUILayout.Width(80)))
{
// Delete everything
Undo.RecordObject(m_CurrentAsset, "Clear All Processors");
m_processorStack.RemoveAllProcessors(m_CurrentAsset);
// Update UI
m_ProcessorsReorderableList.index = -1;
m_CurrentProcessor = null;
m_LockedPreviewProcessor = null;
m_CurrentAsset.editSettings.lockedProcessor = -1;
m_CurrentAsset.editSettings.selectedProcessor = -1;
m_PreviewCanvas.sequence = m_processorStack.inputSequence;
EditorUtility.SetDirty(m_CurrentAsset);
// Request Repaint
Invalidate();
RefreshCanvas();
return;
}
}
GUILayout.Space(8);
}
m_ProcessorsReorderableList.DoLayoutList();
if (m_IgnoreInheritSettings || m_CurrentAsset.inheritSettingsReference == null)
{
GUILayout.Space(10);
// Draw inspector and Invalidates whatever needs to.
for (int i = 0; i < m_processorStack.processors.Count; i++)
{
if (m_ProcessorsReorderableList.index == i)
{
bool changed = m_processorStack.processors[i].OnSidePanelGUI(m_CurrentAsset, i);
if (changed)
{
m_processorStack.processors[i].Invalidate();
UpdateViewport();
}
m_Dirty = m_Dirty || changed;
}
}
}
else
{
EditorGUILayout.HelpBox("Settings cannot be accessed when linked from external Image Sequence", MessageType.Info);
}
// Handle final keyboard events (delete)
if (Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.Delete && m_processorStack.processors.Count > 0)
{
MenuRemoveProcessor(m_ProcessorsReorderableList);
Event.current.Use();
}
}
public void LoadProcessorsFromAsset(ImageSequence asset)
{
m_Processors.Clear();
var infos = asset.processorInfos;
// Creating Runtime
foreach (ProcessorInfo procInfo in infos)
{
switch (procInfo.ProcessorName)
{
case "Crop":
m_Processors.Add(new CropProcessor(this, procInfo));
break;
case "Rotate":
m_Processors.Add(new RotateProcessor(this, procInfo));
break;
case "Retime":
m_Processors.Add(new RetimeProcessor(this, procInfo));
break;
case "Looping":
m_Processors.Add(new LoopingProcessor(this, procInfo));
break;
case "Decimate":
m_Processors.Add(new DecimateProcessor(this, procInfo));
break;
case "Remove Background":
m_Processors.Add(new RemoveBackgroundBlendingProcessor(this, procInfo));
break;
case "Fade":
m_Processors.Add(new FadeProcessor(this, procInfo));
break;
case "Assemble Flipbook":
m_Processors.Add(new AssembleProcessor(this, procInfo));
break;
case "Premultiply Alpha":
m_Processors.Add(new PremultiplyAlphaProcessor(this, procInfo));
break;
case "Color Correction":
m_Processors.Add(new ColorCorrectionProcessor(this, procInfo));
break;
case "Alpha From RGB":
m_Processors.Add(new AlphaFromRGBProcessor(this, procInfo));
break;
case "Remap Color":
m_Processors.Add(new RemapColorProcessor(this, procInfo));
break;
case "Fix Borders":
m_Processors.Add(new FixBordersProcessor(this, procInfo));
break;
case "Resize":
m_Processors.Add(new ResizeProcessor(this, procInfo));
break;
case "Break Flipbook":
m_Processors.Add(new BreakFlipbookProcessor(this, procInfo));
break;
case "Custom Material":
m_Processors.Add(new CustomMaterialProcessor(this, procInfo));
break;
default:
Debug.LogError("Could Not deserizlize " + procInfo + " , Unrecognized processor;");
break;
}
}
}
