public static IEnumerator <CommandDelegate> CoroutineOne(Ref <float> val, int depth, Ref <int> calledCount)
{
if (depth > 0)
{
++calledCount.Value;
yield return(Cmd.ChangeTo(val, 5.0f, 4.0f));
yield return(Cmd.WaitForSeconds(1.0f));
yield return(Cmd.ChangeBy(val, -4.0f, 4.0f));
yield return(null); // Wait for a single frame
yield return(Cmd.Coroutine(() => CoroutineOne(val, depth - 1, calledCount)));
}
}
/// <summary>
/// Pulsates a value.
/// </summary>
/// <param name="amount">The amount to increase the value by.</param>
public static CommandDelegate PulsateScale(Ref <float> scale, float amount, double duration)
{
CheckArgumentNonNull(scale, "scale");
CommandDelegate tweenBack = null;
return(Cmd.Sequence(
Cmd.Do(() =>
{
// Because we don't know what the original scale is at this point,
// we have to recreate the scale back tween every time.
tweenBack = Cmd.ChangeTo(scale, scale.Value, duration / 2.0, Ease.Smooth());
}),
Cmd.ChangeBy(scale, amount, duration / 2.0, Ease.Smooth()),
Cmd.Defer(() => tweenBack)
));
}
public static void TestChangeBy()
{
const float floatOffset = 4.8f;
const float floatStart = 1.2f;
float floatVal = floatStart;
Ref <float> floatRef = new Ref <float>(
() => floatVal,
t => floatVal = t
);
const double doubleOffset = 3.2;
const double doubleStart = 9.2;
double doubleVal = doubleStart;
Ref <double> doubleRef = new Ref <double>(
() => doubleVal,
t => doubleVal = t
);
Vector2 vec2Offset = new Vector2(9.5f, 2.0f);
Vector2 vec2Start = new Vector2(4.0f, 5.0f);
Vector2 vec2Val = vec2Start;
Ref <Vector2> vec2Ref = new Ref <Vector2>(
() => vec2Val,
t => vec2Val = t
);
Vector3 vec3Offset = new Vector3(4.0f, 19.0f, 2.0f);
Vector3 vec3Start = new Vector3(92.0f, 0.5f, 34.0f);
Vector3 vec3Val = vec3Start;
Ref <Vector3> vec3Ref = new Ref <Vector3>(
() => vec3Val,
t => vec3Val = t
);
Vector4 vec4Offset = new Vector4(92.0f, 0.5f, 14.0f, 7.0f);
Vector4 vec4Start = new Vector4(0.4f, 10.0f, 3.0f, 82.0f);
Vector4 vec4Val = vec4Start;
Ref <Vector4> vec4Ref = new Ref <Vector4>(
() => vec4Val,
t => vec4Val = t
);
CommandQueue queue = new CommandQueue();
queue.Enqueue(
Cmd.Repeat(2,
Cmd.Parallel(
Cmd.ChangeBy(floatRef, floatOffset, 1.0),
Cmd.ChangeBy(doubleRef, doubleOffset, 1.0),
Cmd.ChangeBy(vec2Ref, vec2Offset, 1.0),
Cmd.ChangeBy(vec3Ref, vec3Offset, 1.0),
Cmd.ChangeBy(vec4Ref, vec4Offset, 1.0)
)
)
);
queue.Update(0.3);
// Check basic lerping works.
Assert.AreEqual(floatVal, floatOffset * 0.3f + floatStart, 0.01);
Assert.AreEqual(doubleVal, doubleOffset * 0.3 + doubleStart, 0.01);
AreEqual(vec2Val, vec2Offset * 0.3f + vec2Start, 0.01f);
AreEqual(vec3Val, vec3Offset * 0.3f + vec3Start, 0.01f);
AreEqual(vec4Val, vec4Offset * 0.3f + vec4Start, 0.01f);
queue.Update(0.7);
// Completes the offset
Assert.AreEqual(floatVal, floatOffset + floatStart, 0.01f);
Assert.AreEqual(doubleVal, doubleOffset + doubleStart, 0.01);
AreEqual(vec2Val, vec2Offset + vec2Start, 0.01f);
AreEqual(vec3Val, vec3Offset + vec3Start, 0.01f);
AreEqual(vec4Val, vec4Offset + vec4Start, 0.01f);
queue.Update(0.3);
// Check that it compounds the result
Assert.AreEqual(floatVal, floatOffset * 1.3f + floatStart, 0.01f);
Assert.AreEqual(doubleVal, doubleOffset * 1.3 + doubleStart, 0.01);
AreEqual(vec2Val, vec2Offset * 1.3f + vec2Start, 0.01f);
AreEqual(vec3Val, vec3Offset * 1.3f + vec3Start, 0.01f);
AreEqual(vec4Val, vec4Offset * 1.3f + vec4Start, 0.01f);
// Reset the vals to zero.
floatVal = 0.0f;
doubleVal = 0.0;
vec2Val = Vector2.zero;
vec3Val = Vector3.zero;
vec4Val = Vector4.zero;
queue.Update(0.7);
// And check the offset continues.
Assert.AreEqual(floatVal, floatOffset * 0.7f, 0.01f);
Assert.AreEqual(doubleVal, doubleOffset * 0.7, 0.01);
AreEqual(vec2Val, vec2Offset * 0.7f, 0.01f);
AreEqual(vec3Val, vec3Offset * 0.7f, 0.01f);
AreEqual(vec4Val, vec4Offset * 0.7f, 0.01f);
}