namespace UnityEditor.VFXToolbox.ImageSequencer
{
internal abstract class ProcessorBase : ScriptableObject
/// <summary>
/// Base Class for Custom Processors. Derive from this class to add a new Processor.
/// In order to populate processors in the menu, you need to implement the [ProcessorAttribute] to the class.
/// </summary>
public abstract class ProcessorBase : ScriptableObject
/// <summary>
/// Asset Path of the Shader used for this processor (eg: "Assets/Shaders/MyShader.shader")
/// </summary>
/// <summary>
/// Name of the Processor
/// </summary>
/// <summary>
/// Display Label text of the processor (will be displayed in the processor list and asset inspector)
/// </summary>
protected ProcessingNode processor ;
/// <summary>
/// Number of U (Columns) defined by this processor. Implement to override default (passthrough input sequence's numU)
/// </summary>
public virtual int numU = > inputSequenceNumU ;
/// <summary>
/// Number of V (Rows) defined by this processor. Implement to override default (passthrough input sequence's numV)
/// </summary>
public virtual int numV = > inputSequenceNumV ;
public void AttachTo ( ProcessingNode processor )
{
this . processor = processor ;
}
/// <summary>
/// Number of frames defined by this processor. Implement to override default (passthrough input's sequence length)
/// </summary>
public virtual int sequenceLength = > processingNode . InputSequence . length ;
public virtual int numU = > processor . InputSequence . numU ;
public virtual int numV = > processor . InputSequence . numV ;
public virtual int sequenceLength = > processor . InputSequence . length ;
/// <summary>
/// Determines the actual processing of the frame. Will be called when this frame is requested by the Image Sequencer.
/// </summary>
/// <param name="frame">the requested frame index</param>
/// <returns></returns>
/// <summary>
/// Updates the output size of the processing node (resets internal render targets), implement to override the default (passthrough the input sequence frame width and height)
/// </summary>
processor . SetOutputSize ( processor . InputSequence . width , processor . InputSequence . height ) ;
processingNode . SetOutputSize ( processingNode . InputSequence . width , processingNode . InputSequence . height ) ;
/// <summary>
/// Displays the Processor inspector in the left pane of the Image Sequencer
/// </summary>
/// <param name="changed">Whether the inspector has already caught changes.</param>
/// <param name="serializedObject">The processor's serializedObject</param>
/// <returns>whether there has changes to apply</returns>
/// <summary>
/// Displays the Processor's Canvas Helpers as overlay.
/// </summary>
/// <param name="canvas">The Image Sequencer Canvas currently drawn</param>
/// <returns>whether the canvas needs to redraw</returns>
/// <summary>
/// Sets the default values of the processor. Will be called to configure the default state when a new processor is added to the Image Sequence.
/// </summary>
#region PROCESSINGNODE ACCESS
/// <summary>
/// The Input Sequence Frame Count
/// </summary>
public int inputSequenceLength = > processingNode . InputSequence . length ;
/// <summary>
/// The Input Sequence Frame Width (in pixels)
/// </summary>
public int inputSequenceWidth = > processingNode . InputSequence . width ;
/// <summary>
/// The Input Sequence Frame Height (in pixels)
/// </summary>
public int inputSequenceHeight = > processingNode . InputSequence . height ;
/// <summary>
/// The Input Sequence Flipbook U Count (Columns)
/// </summary>
public int inputSequenceNumU = > processingNode . InputSequence . numU ;
/// <summary>
/// The Input Sequence Flipbook V Count (Rows)
/// </summary>
public int inputSequenceNumV = > processingNode . InputSequence . numV ;
/// <summary>
/// Whether the Input frame Sequence is the Asset's Input Frame List (use to determine whether it needs gamma correction or not)
/// </summary>
public bool isInputFrameSequence = > processingNode . InputSequence . processingNode = = null ;
/// <summary>
/// Whether the current processor is being previewed in the Image Sequencer Viewport, or not (for example, when the view is locked to another processor's result)
/// </summary>
public bool isCurrentlyPreviewed = > processingNode . isCurrentlyPreviewed ;
/// <summary>
/// The current Image Sequencer Viewport's preview sequence length. Please not that this is not necessarily this Processor's preview, use isCurrentlyPreviewed to check.
/// </summary>
public int previewSequenceLength = > processingNode . previewSequenceLength ;
/// <summary>
/// The current Image Sequencer Viewport's preview image index. Please not that this is not necessarily this Processor's preview, use isCurrentlyPreviewed to check.
/// </summary>
public int previewCurrentFrame = > processingNode . previewCurrentFrame ;
/// <summary>
/// The material internally used for this processor. It is created from the shader defined using this.shaderPath.
/// </summary>
public Material material = > processingNode . material ;
/// <summary>
/// Requests the Texture (and its Processing) of the Input Sequence Image at given index.
/// </summary>
/// <param name="index">The index of the Frame to be returned.</param>
/// <returns>The texture object corresponding to the frame.</returns>
public Texture RequestInputTexture ( int index )
{
return processingNode . InputSequence . RequestFrame ( index ) . texture ;
}
/// <summary>
/// Requests the Texture of the Output Sequence Image at given index.
/// </summary>
/// <param name="index">The index of the Frame to be returned.</param>
/// <returns>The texture object corresponding to the frame.</returns>
public Texture RequestOutputTexture ( int index )
{
return processingNode . OutputSequence . frames [ index ] . texture ;
}
/// <summary>
/// Sets the Output Size to the Processing Node
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
public void SetOutputSize ( int width , int height )
{
processingNode . SetOutputSize ( width , height ) ;
}
/// <summary>
/// Process the Frame at Given Index, using given material and texture as MainTexture.
/// </summary>
/// <param name="outputIndex">Frame Index to process</param>
/// <param name="mainTexture">Texture object to pass as MainTexture</param>
/// <param name="material">Material to use for the procesing</param>
public void ProcessFrame ( int outputIndex , Texture mainTexture , Material material )
{
processingNode . ExecuteShaderAndDump ( outputIndex , mainTexture , material ) ;
}
/// <summary>
/// Process the Frame at Given Index, using default processor material and texture as MainTexture.
/// </summary>
/// <param name="outputIndex">Frame Index to process</param>
/// <param name="mainTexture">Texture object to pass as MainTexture</param>
public void ProcessFrame ( int outputIndex , Texture mainTexture = null )
{
processingNode . ExecuteShaderAndDump ( outputIndex , mainTexture ) ;
}
/// <summary>
/// Invalidates the Processor (will require to rebake frames)
/// </summary>
public void Invalidate ( )
{
processingNode . Invalidate ( ) ;
}
#endregion
#region INTERNAL
private ProcessingNode processingNode ;
internal void AttachTo ( ProcessingNode processor )
{
this . processingNode = processor ;
}
#endregion
}
}
Thomas ICHÉ
5 年前