public static void TestParallel() { CommandQueue queue = new CommandQueue(); double a = 0.0, b = 0.0, c = 0.0;; queue.Enqueue( Cmd.Repeat(2, Cmd.Parallel( Cmd.Duration((t) => a = t, 4.0), Cmd.Duration((t) => b = t, 3.0), Cmd.Duration((t) => { c = t; Assert.IsTrue(b < c, "Runner not operating con-currently."); Assert.IsTrue(a < b, "Runner not operating con-currently."); }, 2.0) ) ) ); while (!queue.Update(DELTA_TIME_RATE)) { } Assert.AreEqual(a, 1.0, 0.001); Assert.AreEqual(b, 1.0, 0.001); Assert.AreEqual(c, 1.0, 0.001); }
/// <summary> /// Takes an Enumerable of a given type, and a function that converts /// T into a CommandDelegate, the executes them in parallel. /// </summary> /// <param name="collection">A collection of objects.</param> /// <param name="factory">The conversion method.</param> /// <param name="delay"> Each successive element in the collection is delayed by delay * index.</param> public static CommandDelegate ForEachParallelWithDelay <T>(this IEnumerable <T> collection, Func <T, CommandDelegate> factory, double delay) { CheckArgumentNonNull(collection, "collection"); CheckArgumentNonNull(factory, "factory"); CheckDurationGreaterThanZero(delay); var commands = new List <CommandDelegate>(); double totalDelay = 0f; foreach (var item in collection) { CommandDelegate output = factory(item); if (totalDelay > 0.0) { output = Cmd.Sequence( Cmd.WaitForSeconds(totalDelay), output ); } totalDelay += delay; commands.Add(output); } return(Cmd.Parallel(commands.ToArray())); }
public static void TestTiming() { CommandQueue queue = new CommandQueue(); const double FIRST_Command_DURATION = 4.5; const double SECOND_Command_DURATION = 1.0; const double WAIT_DURATION = 1.5; const int REPEAT_COUNT = 8640; double lastT = 0.0; // This test ensures that between alternating CommandDurations, // there is no accumulation of error in timing. We use a repeat // here to accentuate the error. queue.Enqueue( Cmd.Repeat(REPEAT_COUNT, Cmd.Sequence( Cmd.WaitForSeconds(WAIT_DURATION), Cmd.Do(() => lastT = 0.0), Cmd.Duration((t) => { Assert.IsTrue(t <= 1.0); Assert.IsTrue(lastT <= t); lastT = t; }, FIRST_Command_DURATION), Cmd.Do(() => lastT = 0.0), Cmd.Parallel( Cmd.Duration((t) => {}, SECOND_Command_DURATION / 2.0), // The following two Duration Cmd should finish in the same Update call. Cmd.Duration((t) => {}, SECOND_Command_DURATION - (DELTA_TIME_RATE / 2.0)), Cmd.Duration((t) => { Assert.IsTrue(t <= 1.0); Assert.IsTrue(lastT <= t); lastT = t; }, SECOND_Command_DURATION) ) ) ) ); double totalTime = 0.0; while (!queue.Update(DELTA_TIME_RATE)) { totalTime += DELTA_TIME_RATE; } const double EXPECTED_TIME = (FIRST_Command_DURATION + SECOND_Command_DURATION + WAIT_DURATION) * REPEAT_COUNT; Assert.AreEqual(totalTime, EXPECTED_TIME, DELTA_TIME_RATE, "Time delta accumulation too large."); }
/// <summary> /// Takes an Enumerable of a given type, and a function that converts /// T into a CommandDelegate, the executes them in parallel. /// </summary> /// <param name="collection">A collection of objects.</param> /// <param name="factory">The conversion method.</param> public static CommandDelegate ForEachParallel <T>(this IEnumerable <T> collection, Func <T, CommandDelegate> factory) { CheckArgumentNonNull(collection, "collection"); CheckArgumentNonNull(factory, "factory"); var commands = new List <CommandDelegate>(); foreach (var item in collection) { CommandDelegate output = factory(item); commands.Add(output); } return(Cmd.Parallel(commands.ToArray())); }
/// <summary> /// Performs a squash and stretch animation, while changing to a target scale. /// </summary> /// <param name="scale">The value to animate.</param> /// <param name="endScale">The final scale.</param> /// <param name="amplitude">The amplitude of a squash and strech</param> /// <param name="duration">The duration of the animation</param> /// <param name="normal"> The normal of the animation. </param> /// <param name="tangent"> The tangent of the animation. </param> public static CommandDelegate ScaleSquashAndStretchTo(Ref <Vector3> scale, Vector3 endScale, float amplitude, double duration, Vector3 normal, Vector3 tangent) { CheckArgumentNonNull(scale, "scale"); var squashRef = Ref <Vector3> .Create(Vector3.one); var scaleRef = Ref <Vector3> .Create(); return(Cmd.Sequence( Cmd.Do(() => scaleRef.Value = scale.Value), Cmd.Parallel( SquashAndStretch(squashRef, amplitude, duration, normal, tangent), Cmd.ChangeTo(scaleRef, endScale, duration / 4, Ease.Smooth()), Cmd.Duration(t => scale.Value = Vector3.Scale(squashRef.Value, scaleRef.Value), duration) ) )); }
/// <summary> /// Squashes the y axis, while inversely stretching the x axis. /// </summary> /// <param name="val">The value to animate.</param> /// <param name="amplitude">The size of the squash.</param> /// <param name="duration">The duration of the squash.</param> public static CommandDelegate SquashAndStretch(Ref <Vector2> scale, float amplitude, double duration) { CheckArgumentNonNull(scale, "scale"); Vector2 startScale = Vector2.zero; float area = 0f; Ref <float> widthRef = new Ref <float>( () => scale.Value.x, (t) => { Vector2 tempVal = scale.Value; tempVal.x = t; scale.Value = tempVal; } ); return(Cmd.Sequence( Cmd.Do(() => { area = scale.Value.x * scale.Value.y; startScale = scale.Value; }), Cmd.Parallel( Wobble(widthRef, amplitude, duration), Cmd.Duration((t) => { Vector2 tempVal = scale.Value; if (tempVal.x != 0f) { tempVal.y = area / tempVal.x; } scale.Value = tempVal; }, duration) ), Cmd.Do(() => { scale.Value = startScale; }) )); }
public static void TestScaleBy() { const float floatScale = 4.8f; const float floatStart = 1.2f; float floatVal = floatStart; Ref <float> floatRef = new Ref <float>( () => floatVal, t => floatVal = t ); const double doubleScale = 3.2; const double doubleStart = 9.2; double doubleVal = doubleStart; Ref <double> doubleRef = new Ref <double>( () => doubleVal, t => doubleVal = t ); Vector2 vec2Scale = 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 vec3Scale = 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 vec4Scale = 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.Sequence( Cmd.Parallel( Cmd.ScaleBy(floatRef, floatScale, 1.0), Cmd.ScaleBy(doubleRef, doubleScale, 1.0), Cmd.ScaleBy(vec2Ref, vec2Scale, 1.0), Cmd.ScaleBy(vec3Ref, vec3Scale, 1.0), Cmd.ScaleBy(vec4Ref, vec4Scale, 1.0) ), Cmd.WaitForFrames(1) ) ) ); queue.Update(0.2f); Vector2 vec2ExpectedScale = vec2Scale; Vector3 vec3ExpectedScale = vec3Scale; Vector4 vec4ExpectedScale = vec4Scale; vec2ExpectedScale.Scale(new Vector2(0.2f, 0.2f)); vec3ExpectedScale.Scale(new Vector3(0.2f, 0.2f, 0.2f)); vec4ExpectedScale.Scale(new Vector4(0.2f, 0.2f, 0.2f, 0.2f)); vec2ExpectedScale += new Vector2(0.8f, 0.8f); vec3ExpectedScale += new Vector3(0.8f, 0.8f, 0.8f); vec4ExpectedScale += new Vector4(0.8f, 0.8f, 0.8f, 0.8f); vec2ExpectedScale.Scale(vec2Start); vec3ExpectedScale.Scale(vec3Start); vec4ExpectedScale.Scale(vec4Start); AreEqual(floatVal, floatStart * (0.8f + floatScale * 0.2f), 0.001f); AreEqual(doubleVal, doubleStart * (0.8 + doubleScale * 0.2), 0.001f); AreEqual(vec2Val, vec2ExpectedScale, 0.001f); AreEqual(vec3Val, vec3ExpectedScale, 0.001f); AreEqual(vec4Val, vec4ExpectedScale, 0.001f); queue.Update(0.8); vec2ExpectedScale = vec2Scale; vec3ExpectedScale = vec3Scale; vec4ExpectedScale = vec4Scale; vec2ExpectedScale.Scale(vec2Start); vec3ExpectedScale.Scale(vec3Start); vec4ExpectedScale.Scale(vec4Start); AreEqual(floatVal, floatStart * floatScale, 0.001f); AreEqual(doubleVal, doubleStart * doubleScale, 0.001f); AreEqual(vec2Val, vec2ExpectedScale, 0.001f); AreEqual(vec3Val, vec3ExpectedScale, 0.001f); AreEqual(vec4Val, vec4ExpectedScale, 0.001f); floatVal = floatStart; doubleVal = doubleStart; vec2Val = vec2Start; vec3Val = vec3Start; vec4Val = vec4Start; queue.Update(0.0); queue.Update(0.5); vec2ExpectedScale = vec2Scale; vec3ExpectedScale = vec3Scale; vec4ExpectedScale = vec4Scale; vec2ExpectedScale.Scale(new Vector2(0.5f, 0.5f)); vec3ExpectedScale.Scale(new Vector3(0.5f, 0.5f, 0.5f)); vec4ExpectedScale.Scale(new Vector4(0.5f, 0.5f, 0.5f, 0.5f)); vec2ExpectedScale += new Vector2(0.5f, 0.5f); vec3ExpectedScale += new Vector3(0.5f, 0.5f, 0.5f); vec4ExpectedScale += new Vector4(0.5f, 0.5f, 0.5f, 0.5f); vec2ExpectedScale.Scale(vec2Start); vec3ExpectedScale.Scale(vec3Start); vec4ExpectedScale.Scale(vec4Start); AreEqual(floatVal, floatStart * (0.5f + floatScale * 0.5f), 0.001f); AreEqual(doubleVal, doubleStart * (0.5 + doubleScale * 0.5), 0.001f); AreEqual(vec2Val, vec2ExpectedScale, 0.001f); AreEqual(vec3Val, vec3ExpectedScale, 0.001f); AreEqual(vec4Val, vec4ExpectedScale, 0.001f); }
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); }
public static void TestChangeFrom() { const float floatEnd = 4.8f; const float floatStart = 1.2f; float floatVal = floatStart; Ref <float> floatRef = new Ref <float>( () => floatVal, t => floatVal = t ); const double doubleEnd = 3.2; const double doubleStart = 9.2; double doubleVal = doubleStart; Ref <double> doubleRef = new Ref <double>( () => doubleVal, t => doubleVal = t ); Vector2 vec2End = 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 vec3End = 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 vec4End = 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.Sequence( Cmd.Parallel( Cmd.ChangeFrom(floatRef, floatEnd, 1.0), Cmd.ChangeFrom(doubleRef, doubleEnd, 1.0), Cmd.ChangeFrom(vec2Ref, vec2End, 1.0), Cmd.ChangeFrom(vec3Ref, vec3End, 1.0), Cmd.ChangeFrom(vec4Ref, vec4End, 1.0) ), Cmd.WaitForFrames(1) ) ) ); queue.Update(0.3); // Check basic lerping works. AreEqual(floatVal, floatEnd * 0.7f + floatStart * 0.3f, 0.01); AreEqual(doubleVal, doubleEnd * 0.7 + doubleStart * 0.3, 0.01); AreEqual(vec2Val, vec2End * 0.7f + vec2Start * 0.3f, 0.01f); AreEqual(vec3Val, vec3End * 0.7f + vec3Start * 0.3f, 0.01f); AreEqual(vec4Val, vec4End * 0.7f + vec4Start * 0.3f, 0.01f); // Reset the vals to zero. Checks that 'ChangeTo' will force itself back on // track. floatVal = 0.0f; doubleVal = 0.0; vec2Val = Vector2.zero; vec3Val = Vector3.zero; vec4Val = Vector4.zero; queue.Update(0.2); // Completes the offset AreEqual(floatVal, floatEnd * 0.5f + floatStart * 0.5f, 0.01); AreEqual(doubleVal, doubleEnd * 0.5 + doubleStart * 0.5, 0.01); AreEqual(vec2Val, vec2End * 0.5f + vec2Start * 0.5f, 0.01f); AreEqual(vec3Val, vec3End * 0.5f + vec3Start * 0.5f, 0.01f); AreEqual(vec4Val, vec4End * 0.5f + vec4Start * 0.5f, 0.01f); queue.Update(0.5); AreEqual(floatVal, floatStart, 0.01f); AreEqual(doubleVal, doubleStart, 0.01); AreEqual(vec2Val, vec2Start, 0.01f); AreEqual(vec3Val, vec3Start, 0.01f); AreEqual(vec4Val, vec4Start, 0.01f); queue.Update(0.0); queue.Update(0.5); // Check that it does jump on repeat AreEqual(floatVal, floatEnd * 0.5f + floatStart * 0.5f, 0.01); AreEqual(doubleVal, doubleEnd * 0.5 + doubleStart * 0.5, 0.01); AreEqual(vec2Val, vec2End * 0.5f + vec2Start * 0.5f, 0.01f); AreEqual(vec3Val, vec3End * 0.5f + vec3Start * 0.5f, 0.01f); AreEqual(vec4Val, vec4End * 0.5f + vec4Start * 0.5f, 0.01f); Rect rectEnd = new Rect(-1.0f, 1.0f, 5.0f, 5.0f); Rect rectStart = new Rect(0.0f, 2.0f, 6.0f, 6.0f); Rect rectVal = rectStart; Ref <Rect> rectRef = new Ref <Rect>( () => rectVal, t => rectVal = t ); Vector2 firstAnchor = new Vector2(0.0f, 0.0f); Vector2 secondAnchor = new Vector2(1.0f, 0.0f); Vector3 thirdAnchor = new Vector2(0.0f, 1.0f); Vector2 forthAnchor = new Vector2(1.0f, 1.0f); queue = new CommandQueue(); queue.Enqueue( Cmd.ChangeFrom(rectRef, rectEnd, 1.0, firstAnchor), Cmd.WaitForFrames(1), Cmd.ChangeFrom(rectRef, rectEnd, 1.0, secondAnchor), Cmd.WaitForFrames(1), Cmd.ChangeFrom(rectRef, rectEnd, 1.0, thirdAnchor), Cmd.WaitForFrames(1), Cmd.ChangeFrom(rectRef, rectEnd, 1.0, forthAnchor) ); // Test the top left corner. queue.Update(0.5); AreEqual(rectVal, new Rect( -0.5f, 1.5f, (rectStart.width + rectEnd.width) * 0.5f, (rectStart.height + rectEnd.height) * 0.5f), 0.001f ); queue.Update(0.5); AreEqual(rectVal, rectStart, 0.001f); queue.Update(0.0f); // Test the top right corner. queue.Update(0.7); AreEqual(rectVal, new Rect( 5.4f - 5.7f, 1.7f, rectStart.width * 0.7f + rectEnd.width * 0.3f, rectStart.height * 0.7f + rectEnd.height * 0.3f), 0.001f ); queue.Update(0.3); AreEqual(rectVal, rectStart, 0.001f); queue.Update(0.0f); // Test the bottom left corner. queue.Update(0.6); AreEqual(rectVal, new Rect( -0.4f, 7.2f - 5.6f, rectStart.width * 0.6f + rectEnd.width * 0.4f, rectStart.height * 0.6f + rectEnd.height * 0.4f), 0.001f ); queue.Update(0.4); AreEqual(rectVal, rectStart, 0.001f); queue.Update(0.0); // Test the bottom right corner. queue.Update(0.6); AreEqual(rectVal, new Rect( 5.2f - 5.6f, 7.2f - 5.6f, rectStart.width * 0.6f + rectEnd.width * 0.4f, rectStart.height * 0.6f + rectEnd.height * 0.4f), 0.001f ); queue.Update(0.4); AreEqual(rectVal, rectStart, 0.001f); queue.Update(0.0f); }
public CommandQueue Parallel(params CommandDelegate[] commands) => Sequence(Cmd.Parallel(commands));