/// <summary>
/// Create a sequence that is attached to the given transform with.
/// </summary>
public InputSequence CreateSequence(Transform transform, int difficulty)
{
string inputText = GenerateSequenceText(difficulty);
InputSequence sequence = _sequenceOverlay.CreateSequence(inputText, transform);
return(sequence);
}
public override bool Process(int frame)
{
if (m_GradientTexture == null)
{
InitTexture();
}
CurveToTextureUtility.GradientToTexture(settings.Gradient, ref m_GradientTexture);
Texture inputFrame = InputSequence.RequestFrame(frame).texture;
m_Material.SetTexture("_MainTex", inputFrame);
if (settings.ColorSource == RemapColorProcessorSettings.RemapColorSource.sRGBLuminance)
{
m_Material.SetFloat("_Mode", 0);
}
else if (settings.ColorSource == RemapColorProcessorSettings.RemapColorSource.LinearRGBLuminance)
{
m_Material.SetFloat("_Mode", 1);
}
else
{
m_Material.SetFloat("_Mode", 2);
}
m_Material.SetTexture("_Gradient", m_GradientTexture);
ExecuteShaderAndDump(frame, inputFrame);
return(true);
}
public void WhenSequenceIsMatched_OldInputsAreCleared()
{
var sequence2 = new InputSequence(new List <Input>()
{
new Input(JoystickPosition.DOWN),
new Input(JoystickPosition.DOWN_LEFT)
});
buffer.AddInputState(new InputState(JoystickPosition.DOWN));
buffer.AddInputState(new InputState(JoystickPosition.DOWN_LEFT));
buffer.AddInputState(new InputState(JoystickPosition.DOWN));
buffer.AddInputState(new InputState(JoystickPosition.DOWN_LEFT));
buffer.AddInputState(new InputState(JoystickPosition.DOWN));
buffer.AddInputState(new InputState(JoystickPosition.DOWN_LEFT));
buffer.AddInputState(new InputState(JoystickPosition.DOWN));
buffer.AddInputState(new InputState(JoystickPosition.DOWN_RIGHT));
buffer.AddInputState(new InputState(JoystickPosition.RIGHT));
buffer.AddInputState(new InputState(
new HashSet <Button>()
{
Button.BUTTON1
},
JoystickPosition.NEUTRAL));
Assert.IsTrue(buffer.Match(SEQUENCE));
Assert.IsFalse(buffer.Match(sequence2));
}
// check if
private bool AnyChange(InputSequence seqA, InputSequence seqB)
{
if (!Enumerable.SequenceEqual(seqA.gK, seqB.gK))
{
return(true);
}
else if (!Enumerable.SequenceEqual(seqA.vB, seqB.vB))
{
return(true);
}
else if (!Enumerable.SequenceEqual(seqA.vA, seqB.vA))
{
return(true);
}
else if (seqA.mP != seqB.mP)
{
return(true);
}
else if (seqA.mWP != seqB.mWP)
{
return(true);
}
else if (seqA.mSD != seqB.mSD)
{
return(true);
}
else
{
return(false);
}
}
public override bool Process(int frame)
{
int inputlength = InputSequence.length;
int outputlength = GetProcessorSequenceLength();
float t = (float)frame / outputlength;
float Frame;
if (settings.useCurve)
{
Frame = settings.curve.Evaluate(t);
}
else
{
Frame = t * inputlength;
}
float blendFactor = Frame % 1.0f;
int Prev = Mathf.Clamp((int)Mathf.Floor(Frame), 0, inputlength - 1);
int Next = Mathf.Clamp((int)Mathf.Ceil(Frame), 0, inputlength - 1);
Texture prevtex = InputSequence.RequestFrame(Prev).texture;
Texture nexttex = InputSequence.RequestFrame(Next).texture;
m_Material.SetTexture("_MainTex", prevtex);
m_Material.SetTexture("_AltTex", nexttex);
m_Material.SetFloat("_BlendFactor", blendFactor);
ExecuteShaderAndDump(frame, prevtex);
return(true);
}
protected override void UpdateOutputSize()
{
int width = (int)Mathf.Ceil((float)InputSequence.RequestFrame(0).texture.width / settings.FlipbookNumU);
int height = (int)Mathf.Ceil((float)InputSequence.RequestFrame(0).texture.height / settings.FlipbookNumV);
SetOutputSize(width, height);
}
private void AttachSequenceToAsteroid(Asteroid asteroid)
{
string inputText = _texts.FindUniquelyTargetableText();
InputSequence sequence = _sequenceOverlay.CreateSequence(inputText, asteroid.transform);
sequence.OnInputAccepted += delegate { _player.FireAt(asteroid); };
sequence.OnCompleted += delegate { asteroid.Explode(); };
}
public override bool Process(int frame)
{
int targetFrame = frame * settings.DecimateBy;
Texture texture = InputSequence.RequestFrame(targetFrame).texture;
m_Material.SetTexture("_MainTex", texture);
ExecuteShaderAndDump(frame, texture);
return(true);
}
/* RECORD
* */
private void Record(float time)
{
currentSequence.init();
currentSequence.t = time;
// store only true boolean
foreach (KeyCode vkey in System.Enum.GetValues(typeof(KeyCode)))
{
if (Input.GetKey(vkey))
{
currentSequence.gK.Add(vkey);
}
if (Input.GetKeyDown(vkey))
{
currentSequence.gKD.Add(vkey);
}
if (Input.GetKeyUp(vkey))
{
currentSequence.gKU.Add(vkey);
}
}
currentSequence.mP = Input.mousePosition;
currentSequence.mWP = Camera.main.ScreenToWorldPoint(currentSequence.mP);
currentSequence.mSD = Input.mouseScrollDelta;
foreach (string virtualAxis in AxisList)
{
currentSequence.vA.Add(Input.GetAxis(virtualAxis));
}
foreach (string ButtonName in ButtonList)
{
if (Input.GetButton(ButtonName))
{
currentSequence.vB.Add(ButtonName);
}
if (Input.GetButtonDown(ButtonName))
{
currentSequence.vBD.Add(ButtonName);
}
if (Input.GetButtonUp(ButtonName))
{
currentSequence.vBU.Add(ButtonName);
}
}
// only write if something changed
if (AnyChange(oldSequence, currentSequence))
{
//Debug.Log (JsonUtility.ToJson (newSequence));
inputRecordStream.WriteLine(JsonUtility.ToJson(currentSequence));
oldSequence = currentSequence;
}
}
public override bool Process(int frame)
{
Texture inputFrame = InputSequence.RequestFrame(frame).texture;
m_Material.SetTexture("_MainTex", inputFrame);
m_Material.SetInt("_RemoveAlpha", settings.RemoveAlpha?1:0);
m_Material.SetFloat("_AlphaValue", settings.AlphaValue);
ExecuteShaderAndDump(frame, inputFrame);
return(true);
}
public override bool Process(int frame)
{
UpdateOutputSize();
Texture texture = InputSequence.RequestFrame(frame).texture;
m_Material.SetTexture("_MainTex", texture);
m_Material.SetInt("_Mode", (int)settings.FrameRotateMode);
ExecuteShaderAndDump(frame, texture);
return(true);
}
public override bool Process(int frame)
{
Texture tex = InputSequence.RequestFrame(frame).texture;
SetOutputSize(tex.width, tex.height);
m_Material.SetTexture("_MainTex", tex);
m_Material.SetColor("_BackgroundColor", settings.BackgroundColor);
ExecuteShaderAndDump(frame, tex);
return(true);
}
public override bool Process(int frame)
{
Texture texture = InputSequence.RequestFrame(frame).texture;
Vector4 kernelAndSize = new Vector4((float)texture.width / (float)settings.Width, (float)texture.height / (float)settings.Height, (float)settings.Width, (float)settings.Height);
m_Material.SetTexture("_MainTex", texture);
m_Material.SetVector("_KernelAndSize", kernelAndSize);
ExecuteShaderAndDump(frame, texture);
return(true);
}
public override bool Process(int frame)
{
Texture inputFrame = InputSequence.RequestFrame(frame).texture;
m_Material.SetTexture("_MainTex", inputFrame);
m_Material.SetVector("_RGBTint", settings.BWFilterTint);
ExecuteShaderAndDump(frame, inputFrame);
return(true);
}
public override bool Process(int frame)
{
Texture inputFrame = InputSequence.RequestFrame(frame).texture;
m_Material.SetTexture("_MainTex", inputFrame);
m_Material.SetColor("_FadeToColor", settings.FadeToColor);
m_Material.SetFloat("_Ratio", settings.FadeCurve.Evaluate(((float)frame) / GetProcessorSequenceLength()));
ExecuteShaderAndDump(frame, inputFrame);
return(true);
}
public override void Do(ActionArgs args)
{
if (this.Entity != null && args != null && args is ChangeInputSequenceArgs)
{
InputSequence sequence = this.Entity.GetComponent("InputSequence") as InputSequence;
if (sequence != null)
{
sequence.Sequence = ((ChangeInputSequenceArgs)args).NewSequence;
}
}
}
private void AddSequenceToObject(GameObject sceneObject)
{
// Generate a text sequence with a unique among the other sequences active sequences
string text = _texts.FindUniquelyTargetableText();
// Crate a sequence with the given text and object to follow in the scene.
InputSequence sequence = _sequenceOverlay.CreateSequence(text, sceneObject.transform);
// Let's make it so that the object is destroyed when the sequence is completed.
sequence.OnCompleted += delegate { Destroy(sceneObject); };
}
private bool ReadLine() // read a new line in file for the next sequence to play
{
string newline = inputPlaybackStream.ReadLine();
if (newline == null)
{
return(false);
}
nextSequence = JsonUtility.FromJson <InputSequence>(newline);
return(true);
}
public override bool Process(int frame)
{
Texture inputFrame = InputSequence.RequestFrame(frame).texture;
m_Material.SetTexture("_MainTex", inputFrame);
m_Material.SetVector("_FixFactors", settings.FixFactors);
m_Material.SetColor("_FadeToColor", settings.FadeToColor);
m_Material.SetFloat("_FadeToAlpha", settings.FadeToAlpha);
m_Material.SetFloat("_Exponent", settings.Exponent);
ExecuteShaderAndDump(frame, inputFrame);
return(true);
}
protected override bool DrawSidePanelContent(bool hasChanged)
{
var bgColor = m_SerializedObject.FindProperty("BackgroundColor");
EditorGUI.BeginChangeCheck();
using (new GUILayout.HorizontalScope())
{
EditorGUILayout.PropertyField(bgColor, VFXToolboxGUIUtility.Get("Background Color"));
if (GUILayout.Button(VFXToolboxGUIUtility.Get("Grab"), GUILayout.Width(40)))
{
if (InputSequence.length > 0)
{
InputSequence.RequestFrame(0);
Color background;
if (InputSequence.frames[0].texture is RenderTexture)
{
background = VFXToolboxUtility.ReadBack((RenderTexture)InputSequence.frames[0].texture)[0];
}
else
{
Texture2D inputFrame = (Texture2D)InputSequence.frames[0].texture;
RenderTexture rt = RenderTexture.GetTemporary(inputFrame.width, inputFrame.height, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
Graphics.Blit(inputFrame, rt);
background = VFXToolboxUtility.ReadBack(rt)[0];
RenderTexture.ReleaseTemporary(rt);
}
if (QualitySettings.activeColorSpace == ColorSpace.Linear)
{
background = background.gamma;
}
bgColor.colorValue = background;
}
}
}
if (EditorGUI.EndChangeCheck())
{
UpdateOutputSize();
Invalidate();
hasChanged = true;
}
GUILayout.Space(20);
EditorGUILayout.HelpBox("Please select a color corresponding to the solid background of the flipbook to try to reconstruct the pixel's color. \n\nThis filter will only work if your flipbook was rendered on a solid color background. Try the Grab button to fetch the upper left pixel of the first frame, or use the color picker.", MessageType.Info);
return(hasChanged);
}
/* PLAYBACK
* */
private void Play(float time)
{
if (time >= nextSequence.t)
{
oldSequence = currentSequence;
currentSequence = nextSequence;
//Debug.Log (time);
nextSequence.init();
if (!ReadLine())
{
Stop();
Debug.Log("InputPlayback: EndOfFile");
}
}
}
public override bool Process(int frame)
{
UpdateOutputSize();
Texture texture = InputSequence.RequestFrame(frame).texture;
m_Material.SetTexture("_MainTex", texture);
m_Material.SetVector("_CropFactors", new Vector4(
(float)settings.Crop_Left / texture.width,
(float)settings.Crop_Right / texture.width,
(float)settings.Crop_Top / texture.height,
(float)settings.Crop_Bottom / texture.height
));
ExecuteShaderAndDump(frame, texture);
return(true);
}
private void AttachSequence(GameObject obj)
{
string textSequence = _texts.FindUniquelyTargetableText();
InputSequence sequence = _sequenceOverlay.CreateSequence(textSequence, obj.transform);
sequence.OnCompleted += delegate
{
Destroy(obj);
if (_respawn)
{
AddSequenceObject();
}
};
sequence.OnRemoval += delegate
{
Destroy(obj);
};
}
private bool ReadLine() // read a new line in file for the next sequence to play
{
fs.Position = current_pos;
string newline = inputPlaybackStream.ReadLine();
current_pos = fs.Position;
if (newline == null)
{
return(false);
}
try {
nextSequence = JsonUtility.FromJson <InputSequence>(newline);
return(true);
} catch {
return(false);
}
}
public override bool Process(int frame)
{
Texture inputFrame = InputSequence.RequestFrame(frame).texture;
if (settings.material != null)
{
settings.material.SetTexture("_InputFrame", inputFrame);
settings.material.SetVector("_FrameData", new Vector4(OutputWidth, OutputHeight, frame, GetProcessorSequenceLength()));
settings.material.SetVector("_FlipbookData", new Vector4(NumU, NumV, 0, 0));
ExecuteShaderAndDump(frame, inputFrame, settings.material);
}
else
{
m_Material.SetTexture("_MainTex", inputFrame);
ExecuteShaderAndDump(frame, inputFrame);
}
return(true);
}
public void GetPositionData()
{
if (mode == Mode.PlayBack && running == true)
{
if (getTime() >= nextSequence.t)
{
oldSequence = currentSequence;
currentSequence = nextSequence;
nextSequence.init();
if (!ReadLine())
{
eof = true;
Stop();
level_manager.EndGoal(gameObject);
//Debug.Log("InputPlayback: EndOfFile");
}
}
}
}
public override bool Process(int frame)
{
if (m_GradientTexture == null)
{
InitTexture();
}
CurveToTextureUtility.GradientToTexture(settings.Gradient, ref m_GradientTexture);
Texture inputFrame = InputSequence.RequestFrame(frame).texture;
m_Material.SetTexture("_MainTex", inputFrame);
m_Material.SetFloat("_Mode", (int)settings.ColorSource);
m_Material.SetTexture("_Gradient", m_GradientTexture);
ExecuteShaderAndDump(frame, inputFrame);
return(true);
}
public override bool Process(int frame)
{
if (m_CurveTexture == null)
{
InitTexture();
}
CurveToTextureUtility.CurveToTexture(settings.AlphaCurve, ref m_CurveTexture);
Texture inputFrame = InputSequence.RequestFrame(frame).texture;
m_Material.SetTexture("_MainTex", inputFrame);
m_Material.SetFloat("_Brightness", settings.Brightness);
m_Material.SetFloat("_Contrast", settings.Contrast);
m_Material.SetFloat("_Saturation", settings.Saturation);
m_Material.SetTexture("_AlphaCurve", m_CurveTexture);
ExecuteShaderAndDump(frame, inputFrame);
return(true);
}
public override bool Process(int frame)
{
Texture texture = InputSequence.RequestFrame(0).texture;
m_Material.SetTexture("_MainTex", texture);
Vector4 rect = new Vector4();
int u = Mathf.Min(settings.FlipbookNumU, texture.width);
int v = Mathf.Min(settings.FlipbookNumV, texture.height);
int x = frame % settings.FlipbookNumU;
int y = (int)Mathf.Floor((float)frame / u);
rect.x = (float)x;
rect.y = (float)(v - 1) - y;
rect.z = 1.0f / u;
rect.w = 1.0f / v;
m_Material.SetVector("_Rect", rect);
ExecuteShaderAndDump(frame, texture);
return(true);
}
public void SetupWithSequence(InputSequence sequence) {
this._currentSequence = sequence;
}
public override bool Process(int frame)
{
int length = InputSequence.length;
RenderTexture backup = RenderTexture.active;
switch (settings.Mode)
{
case AssembleProcessorSettings.AssembleMode.FullSpriteSheet:
// Blit Every Image inside output
for (int i = 0; i < (settings.FlipbookNumU * settings.FlipbookNumV); i++)
{
int u = i % settings.FlipbookNumU;
int v = (settings.FlipbookNumV - 1) - (int)Mathf.Floor((float)i / settings.FlipbookNumU);
Vector2 size = new Vector2(1.0f / settings.FlipbookNumU, 1.0f / settings.FlipbookNumV);
int idx = Mathf.Clamp(i, 0, length - 1);
Texture currentTexture = InputSequence.RequestFrame(idx).texture;
Vector4 ClipCoordinates = new Vector4(u * size.x, v * size.y, size.x, size.y);
m_Material.SetTexture("_MainTex", currentTexture);
m_Material.SetVector("_CC", ClipCoordinates);
Graphics.Blit(currentTexture, (RenderTexture)m_OutputSequence.frames[0].texture, m_Material);
}
RenderTexture.active = backup;
break;
case AssembleProcessorSettings.AssembleMode.VerticalSequence:
// Blit Every N'th Image inside output
int cycleLength = InputSequence.length / settings.FlipbookNumV;
for (int i = 0; i < settings.FlipbookNumV; i++)
{
int u = 0;
int v = settings.FlipbookNumV - 1 - i;
Vector2 size = new Vector2(1.0f, 1.0f / settings.FlipbookNumV);
int idx = Mathf.Clamp((i * cycleLength) + frame, 0, length - 1);
Texture currentTexture = InputSequence.RequestFrame(idx).texture;
Vector4 ClipCoordinates = new Vector4(u * size.x, v * size.y, size.x, size.y);
m_Material.SetTexture("_MainTex", currentTexture);
m_Material.SetVector("_CC", ClipCoordinates);
Graphics.Blit(currentTexture, (RenderTexture)m_OutputSequence.frames[frame].texture, m_Material);
}
RenderTexture.active = backup;
break;
}
return(true);
}
