2 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
22 #include <dali/public-api/dali-core.h>
23 #include <dali/devel-api/actors/actor-devel.h>
24 #include <dali/devel-api/object/handle-devel.h>
25 #include <dali-test-suite-utils.h>
30 void utc_dali_animation_startuP(void)
32 test_return_value = TET_UNDEF;
35 void utc_dali_animation_cleanuP(void)
37 test_return_value = TET_PASS;
43 static const float ROTATION_EPSILON = 0.0001f;
44 static const float VECTOR4_EPSILON = 0.0001f;
46 // Functor to test whether a Finish signal is emitted
47 struct AnimationFinishCheck
49 AnimationFinishCheck(bool& signalReceived)
50 : mSignalReceived(signalReceived)
54 void operator()(Animation& animation)
56 mSignalReceived = true;
61 mSignalReceived = false;
64 void CheckSignalReceived()
68 tet_printf("Expected Finish signal was not received\n");
77 void CheckSignalNotReceived()
81 tet_printf("Unexpected Finish signal was received\n");
90 bool& mSignalReceived; // owned by individual tests
95 int UtcDaliAnimationConstructorP(void)
97 TestApplication application;
101 DALI_TEST_CHECK( !animation );
105 int UtcDaliAnimationNewP(void)
107 TestApplication application;
109 Animation animation = Animation::New( 1.0f );
111 DALI_TEST_CHECK(animation);
115 int UtcDaliAnimationNewN(void)
117 TestApplication application;
119 Animation animation = Animation::New( -1.0f );
121 DALI_TEST_CHECK(animation);
122 DALI_TEST_EQUALS(animation.GetDuration(), 0.0f, TEST_LOCATION);
126 int UtcDaliAnimationDownCastP(void)
128 TestApplication application;
130 tet_infoline("Testing Dali::Animation::DownCast()");
132 float durationSeconds(1.0f);
133 Animation animation = Animation::New(durationSeconds);
135 BaseHandle object(animation);
137 Animation animation2 = Animation::DownCast(object);
138 DALI_TEST_CHECK(animation2);
140 Animation animation3 = DownCast< Animation >(object);
141 DALI_TEST_CHECK(animation3);
145 int UtcDaliAnimationDownCastN(void)
147 TestApplication application;
149 BaseHandle unInitializedObject;
151 Animation animation1 = Animation::DownCast( unInitializedObject );
152 DALI_TEST_CHECK( !animation1 );
154 Animation animation2 = DownCast< Animation >( unInitializedObject );
155 DALI_TEST_CHECK( !animation2 );
159 int UtcDaliAnimationCopyConstructorP(void)
161 TestApplication application;
163 // Initialize an object, ref count == 1
164 Animation animation = Animation::New( 1.0f );
166 Animation copy( animation );
167 DALI_TEST_CHECK( copy );
169 DALI_TEST_CHECK( copy.GetDuration() == animation.GetDuration() );
173 int UtcDaliAnimationAssignmentOperatorP(void)
175 TestApplication application;
177 Animation animation = Animation::New( 1.0f );
179 Animation copy = animation;
180 DALI_TEST_CHECK( copy );
182 DALI_TEST_CHECK( animation == copy );
184 DALI_TEST_CHECK( copy.GetDuration() == animation.GetDuration() );
188 int UtcDaliAnimationSetDurationP(void)
190 TestApplication application;
192 Actor actor = Actor::New();
193 Stage::GetCurrent().Add(actor);
195 // Build the animation
196 float durationSeconds(1.0f);
197 Animation animation = Animation::New(durationSeconds);
198 DALI_TEST_EQUALS(animation.GetDuration(), durationSeconds, TEST_LOCATION);
200 // Start the animation
201 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
202 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
205 bool signalReceived(false);
206 AnimationFinishCheck finishCheck(signalReceived);
207 animation.FinishedSignal().Connect(&application, finishCheck);
209 application.SendNotification();
210 application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
212 // We didn't expect the animation to finish yet
213 application.SendNotification();
214 finishCheck.CheckSignalNotReceived();
216 application.Render(2u/*just beyond the animation duration*/);
218 // We did expect the animation to finish
219 application.SendNotification();
220 finishCheck.CheckSignalReceived();
221 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
223 // Restart the animation, with a different duration
225 actor.SetPosition(Vector3::ZERO);
226 durationSeconds = 3.5f;
227 animation.SetDuration(durationSeconds);
228 DALI_TEST_EQUALS(animation.GetDuration(), durationSeconds, TEST_LOCATION);
231 application.SendNotification();
232 application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
234 // We didn't expect the animation to finish yet
235 application.SendNotification();
236 finishCheck.CheckSignalNotReceived();
238 application.Render(2u/*just beyond the animation duration*/);
240 // We did expect the animation to finish
241 application.SendNotification();
242 finishCheck.CheckSignalReceived();
243 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
245 // Check that nothing has changed after a couple of buffer swaps
246 application.Render(0);
247 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
248 application.Render(0);
249 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
253 int UtcDaliAnimationSetDurationN(void)
255 TestApplication application;
257 Animation animation = Animation::New( 1.0f );
258 DALI_TEST_EQUALS( animation.GetDuration(), 1.0f, TEST_LOCATION );
260 animation.SetDuration( -1.0f );
261 DALI_TEST_EQUALS( animation.GetDuration(), 0.0f, TEST_LOCATION );
265 int UtcDaliAnimationGetDurationP(void)
267 TestApplication application;
269 Animation animation = Animation::New(1.0f);
270 DALI_TEST_EQUALS(animation.GetDuration(), 1.0f, TEST_LOCATION);
272 animation.SetDuration(2.0f);
273 DALI_TEST_EQUALS(animation.GetDuration(), 2.0f, TEST_LOCATION);
277 int UtcDaliAnimationSetLoopingP(void)
279 TestApplication application;
281 Actor actor = Actor::New();
282 Stage::GetCurrent().Add(actor);
284 // Build the animation
285 float durationSeconds(1.0f);
286 Animation animation = Animation::New(durationSeconds);
287 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
288 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
290 // Start the animation
291 animation.SetLooping(true);
292 DALI_TEST_CHECK(animation.IsLooping());
295 bool signalReceived(false);
296 AnimationFinishCheck finishCheck(signalReceived);
297 animation.FinishedSignal().Connect(&application, finishCheck);
299 application.SendNotification();
302 float intervalSeconds = 0.25f;
303 float progress = 0.0f;
304 for (int iterations = 0; iterations < 5;)
306 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
308 progress += intervalSeconds;
309 DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentPosition(), 0.001f, TEST_LOCATION );
311 if (progress >= 1.0f)
313 progress = progress - 1.0f;
318 // We didn't expect the animation to finish yet
319 application.SendNotification();
320 finishCheck.CheckSignalNotReceived();
322 animation.SetLooping(false);
323 DALI_TEST_CHECK(!animation.IsLooping());
325 application.SendNotification();
326 application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
328 // We did expect the animation to finish
329 application.SendNotification();
330 finishCheck.CheckSignalReceived();
331 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
333 // Check that nothing has changed after a couple of buffer swaps
334 application.Render(0);
335 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
336 application.Render(0);
337 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
341 int UtcDaliAnimationSetLoopCountP(void)
343 TestApplication application;
345 Actor actor = Actor::New();
346 Stage::GetCurrent().Add(actor);
348 // Build the animation
349 float durationSeconds(1.0f);
350 Animation animation = Animation::New(durationSeconds);
351 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
352 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
354 // Start the animation
355 animation.SetLoopCount(3);
356 DALI_TEST_CHECK(animation.IsLooping());
359 bool signalReceived(false);
360 AnimationFinishCheck finishCheck(signalReceived);
361 animation.FinishedSignal().Connect(&application, finishCheck);
363 application.Render(0);
364 application.SendNotification();
365 application.Render(0);
366 application.SendNotification();
367 application.Render(0);
368 application.SendNotification();
369 application.Render(0);
370 application.SendNotification();
373 float intervalSeconds = 3.0f;
375 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
376 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
378 application.Render(0);
379 application.SendNotification();
380 application.Render(0);
381 application.SendNotification();
382 application.Render(0);
383 application.SendNotification();
384 application.Render(0);
385 application.SendNotification();
386 finishCheck.CheckSignalNotReceived();
388 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
390 application.SendNotification();
391 finishCheck.CheckSignalReceived();
392 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
396 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
397 application.SendNotification();
398 finishCheck.CheckSignalNotReceived();
400 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
401 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
402 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
403 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
404 application.SendNotification();
405 finishCheck.CheckSignalNotReceived();
410 int UtcDaliAnimationSetLoopCountP2(void)
412 TestApplication application;
415 // switching between forever and loop count
418 Actor actor = Actor::New();
419 Stage::GetCurrent().Add(actor);
421 // Build the animation
422 float durationSeconds(1.0f);
423 Animation animation = Animation::New(durationSeconds);
424 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
425 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
426 animation.SetEndAction(Animation::Discard);
428 // Start the animation
429 animation.SetLoopCount(3);
430 DALI_TEST_CHECK(animation.IsLooping());
433 bool signalReceived(false);
434 AnimationFinishCheck finishCheck(signalReceived);
435 animation.FinishedSignal().Connect(&application, finishCheck);
437 float intervalSeconds = 3.0f;
439 application.SendNotification();
440 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
441 application.SendNotification();
442 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
443 application.SendNotification();
444 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
445 application.SendNotification();
447 application.SendNotification();
448 finishCheck.CheckSignalReceived();
453 animation.SetLooping(true);
454 DALI_TEST_CHECK(animation.IsLooping());
456 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
457 application.SendNotification();
458 finishCheck.CheckSignalNotReceived();
460 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
461 application.SendNotification();
462 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
463 application.SendNotification();
464 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
465 application.SendNotification();
466 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
467 application.SendNotification();
468 application.SendNotification();
469 finishCheck.CheckSignalNotReceived();
474 animation.SetLoopCount(3);
475 DALI_TEST_CHECK(animation.IsLooping());
478 application.SendNotification();
479 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
480 application.SendNotification();
481 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
482 application.SendNotification();
483 finishCheck.CheckSignalNotReceived();
485 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
486 application.SendNotification();
487 finishCheck.CheckSignalReceived();
492 animation.SetLooping(true);
493 DALI_TEST_CHECK(animation.IsLooping());
495 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
496 application.SendNotification();
497 finishCheck.CheckSignalNotReceived();
499 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
500 application.SendNotification();
501 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
502 application.SendNotification();
503 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
504 application.SendNotification();
505 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
506 application.SendNotification();
507 finishCheck.CheckSignalNotReceived();
512 animation.SetLoopCount(3);
513 DALI_TEST_CHECK(animation.IsLooping());
515 application.SendNotification();
516 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
517 application.SendNotification();
518 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
519 application.SendNotification();
520 finishCheck.CheckSignalNotReceived();
522 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
523 application.SendNotification();
524 finishCheck.CheckSignalNotReceived(); // we never hit play
532 int UtcDaliAnimationSetLoopCountP3(void)
534 TestApplication application;
537 // switching between forever and loop count
539 Actor actor = Actor::New();
540 Stage::GetCurrent().Add(actor);
542 // Build the animation
543 float durationSeconds(1.0f);
544 Animation animation = Animation::New(durationSeconds);
545 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
546 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
547 animation.SetEndAction(Animation::Discard);
549 float intervalSeconds = 3.0f;
551 bool signalReceived(false);
552 AnimationFinishCheck finishCheck(signalReceived);
553 animation.FinishedSignal().Connect(&application, finishCheck);
556 animation.SetLooping(true);
557 DALI_TEST_CHECK(animation.IsLooping());
559 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
560 application.SendNotification();
561 finishCheck.CheckSignalNotReceived();
563 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
564 application.SendNotification();
565 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
566 application.SendNotification();
567 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
568 application.SendNotification();
569 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
570 application.SendNotification();
571 finishCheck.CheckSignalNotReceived();
576 animation.SetLoopCount(3);
577 DALI_TEST_CHECK(animation.IsLooping());
579 application.SendNotification();
580 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
581 application.SendNotification();
582 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
583 application.SendNotification();
584 finishCheck.CheckSignalNotReceived();
586 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
587 application.SendNotification();
588 finishCheck.CheckSignalNotReceived(); // we never hit play
596 int UtcDaliAnimationSetLoopCountP4(void)
598 TestApplication application;
603 Actor actor = Actor::New();
604 Stage::GetCurrent().Add(actor);
606 // Build the animation
607 float durationSeconds(1.0f);
608 Animation animation = Animation::New(durationSeconds);
609 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
610 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
611 animation.SetEndAction(Animation::Bake);
613 float intervalSeconds = 3.0f;
615 bool signalReceived(false);
616 AnimationFinishCheck finishCheck(signalReceived);
617 animation.FinishedSignal().Connect(&application, finishCheck);
619 animation.SetLoopCount(1);
621 DALI_TEST_CHECK(!animation.IsLooping());
623 application.SendNotification();
624 finishCheck.CheckSignalNotReceived();
625 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
626 application.SendNotification();
627 finishCheck.CheckSignalReceived();
629 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
630 actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f) );
634 animation.Play(); // again
635 DALI_TEST_CHECK(!animation.IsLooping());
637 application.SendNotification();
638 finishCheck.CheckSignalNotReceived();
639 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
640 application.SendNotification();
641 finishCheck.CheckSignalReceived();
643 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
648 int UtcDaliAnimationGetLoopCountP(void)
650 TestApplication application;
652 Actor actor = Actor::New();
653 Stage::GetCurrent().Add(actor);
655 // Build the animation
656 float durationSeconds(1.0f);
657 Animation animation = Animation::New(durationSeconds);
658 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
659 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
661 DALI_TEST_CHECK(1 == animation.GetLoopCount());
663 // Start the animation
664 animation.SetLoopCount(3);
665 DALI_TEST_CHECK(animation.IsLooping());
666 DALI_TEST_CHECK(3 == animation.GetLoopCount());
670 application.Render(0);
671 application.SendNotification();
674 float intervalSeconds = 3.0f;
676 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
677 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
679 application.Render(0);
680 application.SendNotification();
682 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
683 application.SendNotification();
685 animation.SetLoopCount(0);
686 DALI_TEST_CHECK(animation.IsLooping());
687 DALI_TEST_CHECK(0 == animation.GetLoopCount());
689 animation.SetLoopCount(1);
690 DALI_TEST_CHECK(!animation.IsLooping());
691 DALI_TEST_CHECK(1 == animation.GetLoopCount());
697 int UtcDaliAnimationGetCurrentLoopP(void)
699 TestApplication application;
701 Actor actor = Actor::New();
702 Stage::GetCurrent().Add(actor);
704 // Build the animation
705 float durationSeconds(1.0f);
706 Animation animation = Animation::New(durationSeconds);
707 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
708 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
710 // Start the animation
711 animation.SetLoopCount(3);
712 DALI_TEST_CHECK(animation.IsLooping());
713 DALI_TEST_CHECK(0 == animation.GetCurrentLoop());
716 bool signalReceived(false);
717 AnimationFinishCheck finishCheck(signalReceived);
718 animation.FinishedSignal().Connect(&application, finishCheck);
720 application.SendNotification();
723 float intervalSeconds = 3.0f;
725 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
726 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
728 application.SendNotification();
729 finishCheck.CheckSignalNotReceived();
730 DALI_TEST_CHECK(2 == animation.GetCurrentLoop());
732 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
734 application.SendNotification();
735 finishCheck.CheckSignalReceived();
736 DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
737 DALI_TEST_CHECK(animation.GetLoopCount() == animation.GetCurrentLoop());
741 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
742 application.SendNotification();
743 finishCheck.CheckSignalNotReceived();
744 DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
746 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
747 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
748 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
749 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
750 application.SendNotification();
751 finishCheck.CheckSignalNotReceived();
752 DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
757 int UtcDaliAnimationIsLoopingP(void)
759 TestApplication application;
761 Animation animation = Animation::New(1.0f);
762 DALI_TEST_CHECK(!animation.IsLooping());
764 animation.SetLooping(true);
765 DALI_TEST_CHECK(animation.IsLooping());
769 int UtcDaliAnimationSetEndActioN(void)
771 TestApplication application;
773 Actor actor = Actor::New();
774 Stage::GetCurrent().Add(actor);
776 // Build the animation
777 float durationSeconds(1.0f);
778 Animation animation = Animation::New(durationSeconds);
779 DALI_TEST_CHECK(animation.GetEndAction() == Animation::Bake);
781 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
782 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
784 // Start the animation
787 bool signalReceived(false);
788 AnimationFinishCheck finishCheck(signalReceived);
789 animation.FinishedSignal().Connect(&application, finishCheck);
791 application.SendNotification();
792 application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
794 // We did expect the animation to finish
795 application.SendNotification();
796 finishCheck.CheckSignalReceived();
797 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
799 // Go back to the start
800 actor.SetPosition(Vector3::ZERO);
801 application.SendNotification();
802 application.Render(0);
803 DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentPosition(), TEST_LOCATION );
805 // Test BakeFinal, animate again, for half the duration
807 animation.SetEndAction(Animation::BakeFinal);
808 DALI_TEST_CHECK(animation.GetEndAction() == Animation::BakeFinal);
811 application.SendNotification();
812 application.Render(static_cast<unsigned int>(durationSeconds*1000.0f*0.5f) /*half of the animation duration*/);
814 // Stop the animation early
817 // We did NOT expect the animation to finish
818 application.SendNotification();
819 finishCheck.CheckSignalNotReceived();
820 DALI_TEST_EQUALS( targetPosition * 0.5f, actor.GetCurrentPosition(), VECTOR4_EPSILON, TEST_LOCATION );
822 // The position should be same with target position in the next frame
823 application.Render(0);
824 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
826 // Go back to the start
827 actor.SetPosition(Vector3::ZERO);
828 application.SendNotification();
829 application.Render(0);
830 DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentPosition(), TEST_LOCATION );
832 // Test EndAction::Discard, animate again, but don't bake this time
834 animation.SetEndAction(Animation::Discard);
835 DALI_TEST_CHECK(animation.GetEndAction() == Animation::Discard);
838 application.SendNotification();
839 application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
841 // We did expect the animation to finish
842 application.SendNotification();
843 finishCheck.CheckSignalReceived();
844 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
846 // The position should be discarded in the next frame
847 application.Render(0);
848 DALI_TEST_EQUALS( Vector3::ZERO/*discarded*/, actor.GetCurrentPosition(), TEST_LOCATION );
850 // Check that nothing has changed after a couple of buffer swaps
851 application.Render(0);
852 DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentPosition(), TEST_LOCATION );
853 application.Render(0);
854 DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentPosition(), TEST_LOCATION );
858 int UtcDaliAnimationGetEndActionP(void)
860 TestApplication application;
862 Animation animation = Animation::New(1.0f);
863 DALI_TEST_CHECK(animation.GetEndAction() == Animation::Bake);
865 animation.SetEndAction(Animation::Discard);
866 DALI_TEST_CHECK(animation.GetEndAction() == Animation::Discard);
868 animation.SetEndAction(Animation::BakeFinal);
869 DALI_TEST_CHECK(animation.GetEndAction() == Animation::BakeFinal);
874 int UtcDaliAnimationSetDisconnectActionP(void)
876 TestApplication application;
877 Stage stage( Stage::GetCurrent() );
879 // Default: BakeFinal
881 Actor actor = Actor::New();
884 // Build the animation
885 float durationSeconds(1.0f);
886 Animation animation = Animation::New(durationSeconds);
887 DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::BakeFinal);
889 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
890 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
892 // Start the animation
895 application.SendNotification();
896 application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
900 application.SendNotification();
901 application.Render();
903 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
908 Actor actor = Actor::New();
911 // Build the animation
912 float durationSeconds(1.0f);
913 Animation animation = Animation::New(durationSeconds);
914 animation.SetDisconnectAction( Animation::Bake );
916 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
917 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
919 // Start the animation
922 application.SendNotification();
923 application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
927 application.SendNotification();
928 application.Render();
930 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition*0.5f, TEST_LOCATION );
935 Actor actor = Actor::New();
938 // Build the animation
939 float durationSeconds(1.0f);
940 Animation animation = Animation::New(durationSeconds);
941 animation.SetDisconnectAction( Animation::Discard );
943 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
944 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
946 // Start the animation
949 application.SendNotification();
950 application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
954 application.SendNotification();
955 application.Render();
957 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
960 // Don't play the animation: disconnect action should not be applied
962 Actor actor = Actor::New();
965 // Build the animation
966 float durationSeconds(1.0f);
967 Animation animation = Animation::New(durationSeconds);
969 Vector3 targetPosition(10.0f, 10.0f, 10.0f);
970 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
972 application.SendNotification();
973 application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
977 application.SendNotification();
978 application.Render();
980 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
986 int UtcDaliAnimationGetDisconnectActionP(void)
988 TestApplication application;
989 Animation animation = Animation::New(1.0f);
990 DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::BakeFinal); // default!
992 animation.SetDisconnectAction(Animation::Discard);
993 DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::Discard);
995 animation.SetDisconnectAction(Animation::Bake);
996 DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::Bake);
1001 int UtcDaliAnimationSetDefaultAlphaFunctionP(void)
1003 TestApplication application;
1005 Animation animation = Animation::New(1.0f);
1006 AlphaFunction func = animation.GetDefaultAlphaFunction();
1007 DALI_TEST_EQUALS(func.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
1009 animation.SetDefaultAlphaFunction(AlphaFunction::EASE_IN);
1010 AlphaFunction func2 = animation.GetDefaultAlphaFunction();
1011 DALI_TEST_EQUALS(func2.GetBuiltinFunction(), AlphaFunction::EASE_IN, TEST_LOCATION);
1015 int UtcDaliAnimationGetDefaultAlphaFunctionP(void)
1017 TestApplication application;
1019 Animation animation = Animation::New(1.0f);
1020 AlphaFunction func = animation.GetDefaultAlphaFunction();
1022 // Test that the default is linear
1023 DALI_TEST_EQUALS(func.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
1025 animation.SetDefaultAlphaFunction(AlphaFunction::EASE_IN);
1026 AlphaFunction func2 = animation.GetDefaultAlphaFunction();
1027 DALI_TEST_EQUALS(func2.GetBuiltinFunction(), AlphaFunction::EASE_IN, TEST_LOCATION);
1032 int UtcDaliAnimationSetCurrentProgressP(void)
1034 TestApplication application;
1036 Actor actor = Actor::New();
1037 Stage::GetCurrent().Add(actor);
1039 // Build the animation
1040 Animation animation = Animation::New(0.0f);
1043 float durationSeconds(1.0f);
1044 animation.SetDuration(durationSeconds);
1046 bool signalReceived(false);
1047 AnimationFinishCheck finishCheck(signalReceived);
1048 animation.FinishedSignal().Connect(&application, finishCheck);
1049 application.SendNotification();
1051 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1052 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
1054 // Start the animation from 40% progress
1055 animation.SetCurrentProgress( 0.4f );
1058 application.SendNotification();
1059 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
1061 // We didn't expect the animation to finish yet
1062 application.SendNotification();
1063 finishCheck.CheckSignalNotReceived();
1064 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
1065 DALI_TEST_EQUALS( 0.6f, animation.GetCurrentProgress(), TEST_LOCATION );
1067 animation.Play(); // Test that calling play has no effect, when animation is already playing
1068 application.SendNotification();
1070 //Set the progress to 70%
1071 animation.SetCurrentProgress( 0.7f );
1072 application.SendNotification();
1073 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 80% progress */);
1074 DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
1076 application.SendNotification();
1077 finishCheck.CheckSignalNotReceived();
1078 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
1079 DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
1081 application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
1082 // We did expect the animation to finish
1083 application.SendNotification();
1084 finishCheck.CheckSignalReceived();
1085 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
1087 // Check that nothing has changed after a couple of buffer swaps
1088 application.Render(0);
1089 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1090 application.Render(0);
1091 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1095 int UtcDaliAnimationSetCurrentProgressN(void)
1097 TestApplication application;
1099 Actor actor = Actor::New();
1100 Stage::GetCurrent().Add(actor);
1102 // Build the animation
1103 Animation animation = Animation::New(0.0f);
1106 float durationSeconds(1.0f);
1107 animation.SetDuration(durationSeconds);
1109 bool signalReceived(false);
1110 AnimationFinishCheck finishCheck(signalReceived);
1111 animation.FinishedSignal().Connect(&application, finishCheck);
1112 application.SendNotification();
1114 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1115 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
1117 //Trying to set the current cursor outside the range [0..1] is ignored
1118 animation.SetCurrentProgress( -1.0f);
1119 application.SendNotification();
1120 DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
1122 animation.SetCurrentProgress( 100.0f);
1123 application.SendNotification();
1124 DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
1128 int UtcDaliAnimationGetCurrentProgressP(void)
1130 TestApplication application;
1132 Actor actor = Actor::New();
1133 Stage::GetCurrent().Add(actor);
1135 // Build the animation
1136 Animation animation = Animation::New(0.0f);
1139 //Test GetCurrentProgress return 0.0 as the duration is 0.0
1140 DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
1142 animation.SetCurrentProgress( 0.5f );
1143 application.SendNotification();
1144 application.Render(static_cast<unsigned int>(100.0f));
1146 //Progress should still be 0.0
1147 DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
1150 float durationSeconds(1.0f);
1151 animation.SetDuration(durationSeconds);
1152 application.SendNotification();
1154 bool signalReceived(false);
1155 AnimationFinishCheck finishCheck(signalReceived);
1156 animation.FinishedSignal().Connect(&application, finishCheck);
1157 application.SendNotification();
1159 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1160 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
1162 // Start the animation from 40% progress
1163 animation.SetCurrentProgress( 0.4f );
1166 application.SendNotification();
1167 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
1169 // We didn't expect the animation to finish yet
1170 application.SendNotification();
1171 finishCheck.CheckSignalNotReceived();
1172 DALI_TEST_EQUALS( 0.6f, animation.GetCurrentProgress(), TEST_LOCATION );
1174 animation.Play(); // Test that calling play has no effect, when animation is already playing
1175 application.SendNotification();
1177 //Set the progress to 70%
1178 animation.SetCurrentProgress( 0.7f );
1179 application.SendNotification();
1180 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 80% progress */);
1181 DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
1183 application.SendNotification();
1184 finishCheck.CheckSignalNotReceived();
1185 DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
1187 application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
1188 // We did expect the animation to finish
1189 application.SendNotification();
1190 finishCheck.CheckSignalReceived();
1194 int UtcDaliAnimationSetSpeedFactorP1(void)
1196 TestApplication application;
1198 tet_printf("Testing that setting a speed factor of 2 takes half the time\n");
1200 Actor actor = Actor::New();
1201 Stage::GetCurrent().Add(actor);
1203 // Build the animation
1204 float durationSeconds(1.0f);
1205 Animation animation = Animation::New(durationSeconds);
1207 const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
1208 const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1210 KeyFrames keyframes = KeyFrames::New();
1211 keyframes.Add( 0.0f, initialPosition);
1212 keyframes.Add( 1.0f, targetPosition );
1213 animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1215 //Set speed to be x2
1216 animation.SetSpeedFactor(2.0f);
1218 // Start the animation
1221 bool signalReceived(false);
1222 AnimationFinishCheck finishCheck(signalReceived);
1223 animation.FinishedSignal().Connect(&application, finishCheck);
1225 application.SendNotification();
1226 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
1228 // We didn't expect the animation to finish yet
1229 application.SendNotification();
1230 finishCheck.CheckSignalNotReceived();
1231 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
1233 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
1235 // We didn't expect the animation to finish yet
1236 application.SendNotification();
1237 finishCheck.CheckSignalNotReceived();
1238 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
1240 application.Render(static_cast<unsigned int>(durationSeconds*100.0f) + 1u/*just beyond half the duration*/);
1242 // We did expect the animation to finish
1243 application.SendNotification();
1244 finishCheck.CheckSignalReceived();
1245 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
1247 // Check that nothing has changed after a couple of buffer swaps
1248 application.Render(0);
1249 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1250 application.Render(0);
1251 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1256 int UtcDaliAnimationSetSpeedFactorP2(void)
1258 TestApplication application;
1260 Actor actor = Actor::New();
1261 Stage::GetCurrent().Add(actor);
1263 // Build the animation
1264 float durationSeconds(1.0f);
1265 Animation animation = Animation::New(durationSeconds);
1267 const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
1268 const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1270 KeyFrames keyframes = KeyFrames::New();
1271 keyframes.Add( 0.0f, initialPosition);
1272 keyframes.Add( 1.0f, targetPosition );
1273 animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1275 tet_printf("Test -1 speed factor. Animation will play in reverse at normal speed\n");
1276 animation.SetSpeedFactor( -1.0f );
1278 // Start the animation
1281 bool signalReceived(false);
1282 AnimationFinishCheck finishCheck(signalReceived);
1283 animation.FinishedSignal().Connect(&application, finishCheck);
1285 application.SendNotification();
1286 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
1288 // We didn't expect the animation to finish yet
1289 application.SendNotification();
1290 finishCheck.CheckSignalNotReceived();
1291 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
1293 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
1295 // We didn't expect the animation to finish yet
1296 application.SendNotification();
1297 finishCheck.CheckSignalNotReceived();
1298 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
1300 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
1302 // We didn't expect the animation to finish yet
1303 application.SendNotification();
1304 finishCheck.CheckSignalNotReceived();
1305 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
1307 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
1309 // We didn't expect the animation to finish yet
1310 application.SendNotification();
1311 finishCheck.CheckSignalNotReceived();
1312 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
1314 application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
1316 // We did expect the animation to finish
1317 application.SendNotification();
1318 finishCheck.CheckSignalReceived();
1319 DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
1321 // Check that nothing has changed after a couple of buffer swaps
1322 application.Render(0);
1323 DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1324 application.Render(0);
1325 DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1330 int UtcDaliAnimationSetSpeedFactorP3(void)
1332 TestApplication application;
1334 Actor actor = Actor::New();
1335 Stage::GetCurrent().Add(actor);
1337 // Build the animation
1338 float durationSeconds(1.0f);
1339 Animation animation = Animation::New(durationSeconds);
1341 const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
1342 const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1344 KeyFrames keyframes = KeyFrames::New();
1345 keyframes.Add( 0.0f, initialPosition);
1346 keyframes.Add( 1.0f, targetPosition );
1347 animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1349 bool signalReceived(false);
1350 AnimationFinishCheck finishCheck(signalReceived);
1351 animation.FinishedSignal().Connect(&application, finishCheck);
1353 tet_printf("Test half speed factor. Animation will take twice the duration\n");
1355 //Set speed to be half of normal speed
1356 animation.SetSpeedFactor( 0.5f );
1358 // Start the animation
1361 application.SendNotification();
1362 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
1364 // We didn't expect the animation to finish yet
1365 application.SendNotification();
1366 finishCheck.CheckSignalNotReceived();
1367 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.1f), TEST_LOCATION );
1369 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
1371 // We didn't expect the animation to finish yet
1372 application.SendNotification();
1373 finishCheck.CheckSignalNotReceived();
1374 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
1376 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
1378 // We didn't expect the animation to finish yet
1379 application.SendNotification();
1380 finishCheck.CheckSignalNotReceived();
1381 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.3f), TEST_LOCATION );
1383 application.SendNotification();
1384 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
1386 // We didn't expect the animation to finish yet
1387 application.SendNotification();
1388 finishCheck.CheckSignalNotReceived();
1389 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
1391 application.Render(static_cast<unsigned int>(durationSeconds*1200.0f) + 1u/*just beyond the animation duration*/);
1393 // We did expect the animation to finish
1394 application.SendNotification();
1395 finishCheck.CheckSignalReceived();
1396 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
1398 // Check that nothing has changed after a couple of buffer swaps
1399 application.Render(0);
1400 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1401 application.Render(0);
1402 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1407 int UtcDaliAnimationSetSpeedFactorP4(void)
1409 TestApplication application;
1411 Actor actor = Actor::New();
1412 Stage::GetCurrent().Add(actor);
1414 // Build the animation
1415 float durationSeconds(1.0f);
1416 Animation animation = Animation::New(durationSeconds);
1418 const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
1419 const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1421 KeyFrames keyframes = KeyFrames::New();
1422 keyframes.Add( 0.0f, initialPosition);
1423 keyframes.Add( 1.0f, targetPosition );
1424 animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1426 bool signalReceived(false);
1427 AnimationFinishCheck finishCheck(signalReceived);
1428 animation.FinishedSignal().Connect(&application, finishCheck);
1430 tet_printf("Test half speed factor. Animation will take twice the duration\n");
1432 tet_printf("Set speed to be half of normal speed\n");
1433 tet_printf("SetSpeedFactor(0.5f)\n");
1434 animation.SetSpeedFactor( 0.5f );
1436 // Start the animation
1439 application.SendNotification();
1440 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
1442 // We didn't expect the animation to finish yet
1443 application.SendNotification();
1444 finishCheck.CheckSignalNotReceived();
1445 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.1f), TEST_LOCATION );
1447 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
1449 // We didn't expect the animation to finish yet
1450 application.SendNotification();
1451 finishCheck.CheckSignalNotReceived();
1452 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
1454 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
1456 // We didn't expect the animation to finish yet
1457 application.SendNotification();
1458 finishCheck.CheckSignalNotReceived();
1459 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.3f), TEST_LOCATION );
1461 tet_printf("Reverse direction of animation whilst playing\n");
1462 tet_printf("SetSpeedFactor(-0.5f)\n");
1463 animation.SetSpeedFactor(-0.5f);
1465 application.SendNotification();
1466 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
1468 // We didn't expect the animation to finish yet
1469 application.SendNotification();
1470 finishCheck.CheckSignalNotReceived();
1471 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
1473 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
1475 // We didn't expect the animation to finish yet
1476 application.SendNotification();
1477 finishCheck.CheckSignalNotReceived();
1478 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.1f), 0.0001, TEST_LOCATION );
1480 application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
1482 // We did expect the animation to finish
1483 application.SendNotification();
1484 finishCheck.CheckSignalReceived();
1485 DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
1487 // Check that nothing has changed after a couple of buffer swaps
1488 application.Render(0);
1489 DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1490 application.Render(0);
1491 DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1495 int UtcDaliAnimationSetSpeedFactorAndRange(void)
1497 TestApplication application;
1499 const unsigned int NUM_FRAMES(15);
1507 float expected[NUM_FRAMES];
1510 TestData testData[] = {
1512 /*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
1513 /* |----------PlayRange---------------| */
1515 { 0.0f, 1.0f, // TimePeriod
1516 0.0f, 100.0f, // POS
1517 {/**/ 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, /* Loop */
1518 /**/ 30.0f, 40.0f, 50.0f, 60.0f, /* Reverse direction */
1529 // ACTOR 1 - Across start of range
1530 /*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
1531 /* |----------PlayRange---------------| */
1533 { 0.2f, 0.5f, // TimePeriod
1534 20.0f, 50.0f, // POS
1535 {/**/ 30.0f, 40.0f, 50.0f, 50.0f, 50.0f, /* Loop */
1536 /**/ 30.0f, 40.0f, 50.0f, 50.0f, /* Reverse direction @ frame #9 */
1546 // ACTOR 2 - Across end of range
1547 /*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
1548 /* |----------PlayRange---------------| */
1550 {/**/ 0.5f, 0.9f, // TimePeriod
1551 /**/ 50.0f, 90.0f, // POS
1552 { /**/ 50.0f, 50.0f, 50.0f, 60.0f, 70.0f, /* Loop */
1553 /**/ 50.0f, 50.0f, 50.0f, 60.0f,/* Reverse direction @ frame #9 */
1562 // ACTOR 3 - Before beginning of range
1563 /*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
1564 /* |----------PlayRange---------------| */
1566 {/**/ 0.1f, 0.25f, // TimePeriod
1567 /**/ 10.0f, 25.0f, // POS
1569 /**/ 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f
1574 // ACTOR 4 - After end of range
1575 /*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
1576 /* |----------PlayRange---------------| */
1578 {/**/ 0.85f, 1.0f, // TimePeriod
1579 /**/ 85.0f, 100.0f, // POS
1581 /**/ 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f
1585 // Actor 5 - Middle of range
1586 /*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
1587 /* |----------PlayRange---------------| */
1589 {/**/ 0.4f, 0.65f, // Time Period
1590 /**/ 40.0f, 65.0f, // Position
1591 { /**/ 40.0f, 40.0f, 50.0f, 60.0f, 65.0f,
1592 /**/ 40.0f, 40.0f, 50.0f, 60.0f, // Reverse
1603 const size_t NUM_ENTRIES(sizeof(testData)/sizeof(TestData));
1605 // Build the animation
1606 float durationSeconds(1.0f);
1607 Animation animation = Animation::New(durationSeconds);
1608 bool signalReceived(false);
1609 AnimationFinishCheck finishCheck(signalReceived);
1610 animation.FinishedSignal().Connect(&application, finishCheck);
1612 std::vector<Dali::Actor> actors;
1614 for( unsigned int actorIndex = 0; actorIndex < NUM_ENTRIES; ++actorIndex )
1616 Actor actor = Actor::New();
1617 actor.SetPosition( Vector3( testData[actorIndex].startX, 0, 0 ) );
1618 actors.push_back(actor);
1619 Stage::GetCurrent().Add(actor);
1621 if( actorIndex == 0 || actorIndex == NUM_ENTRIES-1 )
1623 KeyFrames keyframes = KeyFrames::New();
1624 keyframes.Add( testData[actorIndex].startTime, Vector3(testData[actorIndex].startX, 0, 0));
1625 keyframes.Add( testData[actorIndex].endTime, Vector3(testData[actorIndex].endX, 0, 0));
1626 animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1630 animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( testData[actorIndex].endX, 0, 0 ), TimePeriod( testData[actorIndex].startTime, testData[actorIndex].endTime - testData[actorIndex].startTime) );
1634 tet_printf("Test half speed factor. Animation will take twice the duration\n");
1635 tet_printf("Set play range to be 0.3 - 0.8 of the duration\n");
1636 tet_printf("SetSpeedFactor(0.5f)\n");
1637 animation.SetSpeedFactor( 0.5f );
1638 animation.SetPlayRange( Vector2(0.3f, 0.8f) );
1639 animation.SetLooping(true);
1641 // Start the animation
1643 application.SendNotification();
1644 application.Render(0); // Frame 0 tests initial values
1646 for( unsigned int frame = 0; frame < NUM_FRAMES; ++frame )
1648 unsigned int actorIndex = 0u;
1649 for( actorIndex = 0u; actorIndex < NUM_ENTRIES; ++actorIndex )
1651 DALI_TEST_EQUALS( actors[actorIndex].GetCurrentPosition().x, testData[actorIndex].expected[frame], 0.001, TEST_LOCATION );
1652 if( ! Equals(actors[actorIndex].GetCurrentPosition().x, testData[actorIndex].expected[frame]) )
1654 tet_printf("Failed at frame %u, actorIndex %u\n", frame, actorIndex );
1660 tet_printf("Reverse direction of animation whilst playing after frame 8\n");
1661 tet_printf("SetSpeedFactor(-0.5f)\n");
1662 animation.SetSpeedFactor(-0.5f);
1663 application.SendNotification();
1665 application.Render(200); // 200 ms at half speed corresponds to 0.1 s
1667 // We didn't expect the animation to finish yet
1668 application.SendNotification();
1669 finishCheck.CheckSignalNotReceived();
1675 int UtcDaliAnimationSetSpeedFactorRangeAndLoopCount01(void)
1677 TestApplication application;
1679 const unsigned int NUM_FRAMES(15);
1687 float expected[NUM_FRAMES];
1692 /*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
1693 /* |----------PlayRange---------------| */
1694 { 0.0f, 1.0f, // TimePeriod
1695 0.0f, 100.0f, // POS
1696 {/**/ 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, /* Loop */
1697 /**/ 30.0f, 40.0f, 50.0f, 60.0f, 70.0f,
1698 /**/ 30.0f, 40.0f, 50.0f, 60.0f, 70.0f,
1704 // Build the animation
1705 float durationSeconds(1.0f);
1706 Animation animation = Animation::New(durationSeconds);
1707 bool signalReceived(false);
1708 AnimationFinishCheck finishCheck(signalReceived);
1709 animation.FinishedSignal().Connect(&application, finishCheck);
1711 std::vector<Dali::Actor> actors;
1713 Actor actor = Actor::New();
1714 actor.SetPosition( Vector3( testData.startX, 0, 0 ) );
1715 actors.push_back(actor);
1716 Stage::GetCurrent().Add(actor);
1718 KeyFrames keyframes = KeyFrames::New();
1719 keyframes.Add( testData.startTime, Vector3(testData.startX, 0, 0));
1720 keyframes.Add( testData.endTime, Vector3(testData.endX, 0, 0));
1721 animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1723 tet_printf("Test half speed factor. Animation will take twice the duration\n");
1724 tet_printf("Set play range to be 0.3 - 0.8 of the duration\n");
1725 tet_printf("SetSpeedFactor(0.5f)\n");
1726 tet_printf("SetLoopCount(3)\n");
1727 animation.SetSpeedFactor( 0.5f );
1728 animation.SetPlayRange( Vector2(0.3f, 0.8f) );
1729 animation.SetLoopCount(3);
1731 // Start the animation
1733 application.SendNotification();
1734 application.Render(0); // Frame 0 tests initial values
1736 for( unsigned int frame = 0; frame < NUM_FRAMES; ++frame )
1738 DALI_TEST_EQUALS( actor.GetCurrentPosition().x, testData.expected[frame], 0.001, TEST_LOCATION );
1740 application.Render(200); // 200 ms at half speed corresponds to 0.1 s
1742 if( frame < NUM_FRAMES-1 )
1744 // We didn't expect the animation to finish yet
1745 application.SendNotification();
1746 finishCheck.CheckSignalNotReceived();
1750 // We did expect the animation to finish
1751 application.SendNotification();
1752 finishCheck.CheckSignalReceived();
1753 DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 80.0f, 0.001, TEST_LOCATION );
1758 int UtcDaliAnimationSetSpeedFactorRangeAndLoopCount02(void)
1760 TestApplication application;
1762 const unsigned int NUM_FRAMES(15);
1770 float expected[NUM_FRAMES];
1775 /*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
1776 /* |----------PlayRange---------------| */
1777 { 0.0f, 1.0f, // TimePeriod
1778 0.0f, 100.0f, // POS
1779 {/**/ 80.0f, 70.0f, 60.0f, 50.0f, 40.0f,
1780 /**/ 80.0f, 70.0f, 60.0f, 50.0f, 40.0f,
1781 /**/ 80.0f, 70.0f, 60.0f, 50.0f, 40.0f,
1786 // Build the animation
1787 float durationSeconds(1.0f);
1788 Animation animation = Animation::New(durationSeconds);
1789 bool signalReceived(false);
1790 AnimationFinishCheck finishCheck(signalReceived);
1791 animation.FinishedSignal().Connect(&application, finishCheck);
1793 std::vector<Dali::Actor> actors;
1795 Actor actor = Actor::New();
1796 actor.SetPosition( Vector3( testData.startX, 0, 0 ) );
1797 actors.push_back(actor);
1798 Stage::GetCurrent().Add(actor);
1800 KeyFrames keyframes = KeyFrames::New();
1801 keyframes.Add( testData.startTime, Vector3(testData.startX, 0, 0));
1802 keyframes.Add( testData.endTime, Vector3(testData.endX, 0, 0));
1803 animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1805 tet_printf("Test reverse half speed factor. Animation will take twice the duration\n");
1806 tet_printf("Set play range to be 0.3 - 0.8 of the duration\n");
1807 tet_printf("SetSpeedFactor(-0.5f)\n");
1808 tet_printf("SetLoopCount(3)\n");
1809 animation.SetSpeedFactor( -0.5f );
1810 animation.SetPlayRange( Vector2(0.3f, 0.8f) );
1811 animation.SetLoopCount(3);
1813 // Start the animation
1815 application.SendNotification();
1816 application.Render(0); // Frame 0 tests initial values
1818 for( unsigned int frame = 0; frame < NUM_FRAMES; ++frame )
1820 DALI_TEST_EQUALS( actor.GetCurrentPosition().x, testData.expected[frame], 0.001, TEST_LOCATION );
1822 application.Render(200); // 200 ms at half speed corresponds to 0.1 s
1824 if( frame < NUM_FRAMES-1 )
1826 // We didn't expect the animation to finish yet
1827 application.SendNotification();
1828 finishCheck.CheckSignalNotReceived();
1832 // We did expect the animation to finish
1833 application.SendNotification();
1834 finishCheck.CheckSignalReceived();
1835 DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 30.0f, 0.001, TEST_LOCATION );
1841 int UtcDaliAnimationGetSpeedFactorP(void)
1843 TestApplication application;
1845 Animation animation = Animation::New(1.0f);
1846 animation.SetSpeedFactor(0.5f);
1847 DALI_TEST_EQUALS(animation.GetSpeedFactor(), 0.5f, TEST_LOCATION);
1849 animation.SetSpeedFactor(-2.5f);
1850 DALI_TEST_EQUALS(animation.GetSpeedFactor(), -2.5f, TEST_LOCATION);
1854 int UtcDaliAnimationSetPlayRangeP(void)
1856 TestApplication application;
1858 Actor actor = Actor::New();
1859 Stage::GetCurrent().Add( actor );
1861 // Build the animation
1862 float durationSeconds( 1.0f );
1863 Animation animation = Animation::New( durationSeconds );
1865 bool signalReceived( false );
1866 AnimationFinishCheck finishCheck( signalReceived );
1867 animation.FinishedSignal().Connect( &application, finishCheck );
1868 application.SendNotification();
1870 // Set range between 0.4 and 0.8
1871 animation.SetPlayRange( Vector2( 0.4f, 0.9f ) );
1872 application.SendNotification();
1873 DALI_TEST_EQUALS( Vector2( 0.4f, 0.9f ), animation.GetPlayRange(), TEST_LOCATION );
1875 Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
1876 animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR );
1878 // Start the animation from 40% progress
1881 application.SendNotification();
1882 application.Render( static_cast< unsigned int >( durationSeconds * 200.0f )/* 60% progress */ );
1884 // We didn't expect the animation to finish yet
1885 application.SendNotification();
1886 finishCheck.CheckSignalNotReceived();
1887 DALI_TEST_EQUALS( actor.GetCurrentPosition(), ( targetPosition * 0.6f ), TEST_LOCATION );
1889 application.SendNotification();
1890 application.Render( static_cast< unsigned int >( durationSeconds * 200.0f )/* 80% progress */ );
1892 application.SendNotification();
1893 finishCheck.CheckSignalNotReceived();
1894 DALI_TEST_EQUALS( actor.GetCurrentPosition(), ( targetPosition * 0.8f ), TEST_LOCATION );
1896 application.SendNotification();
1897 application.Render( static_cast< unsigned int >( durationSeconds*100.0f ) + 1u/*just beyond the animation duration*/ );
1899 // We did expect the animation to finish
1900 application.SendNotification();
1901 finishCheck.CheckSignalReceived();
1902 DALI_TEST_EQUALS( actor.GetCurrentPosition(), ( targetPosition * 0.9f ), TEST_LOCATION );
1906 int UtcDaliAnimationSetPlayRangeN(void)
1908 TestApplication application;
1910 Actor actor = Actor::New();
1911 Stage::GetCurrent().Add(actor);
1913 // Build the animation
1914 Animation animation = Animation::New(0);
1915 application.SendNotification();
1917 //PlayRange out of bounds
1918 animation.SetPlayRange( Vector2(-1.0f,1.0f) );
1919 application.SendNotification();
1920 DALI_TEST_EQUALS( Vector2(0.0f,1.0f), animation.GetPlayRange(), TEST_LOCATION );
1921 animation.SetPlayRange( Vector2(0.0f,2.0f) );
1922 application.SendNotification();
1923 DALI_TEST_EQUALS( Vector2(0.0f,1.0f), animation.GetPlayRange(), TEST_LOCATION );
1925 //If playRange is not in the correct order it has to be ordered
1926 animation.SetPlayRange( Vector2(0.8f,0.2f) );
1927 application.SendNotification();
1928 DALI_TEST_EQUALS( Vector2(0.2f,0.8f), animation.GetPlayRange(), TEST_LOCATION );
1933 int UtcDaliAnimationGetPlayRangeP(void)
1935 TestApplication application;
1937 Actor actor = Actor::New();
1938 Stage::GetCurrent().Add( actor );
1940 // Build the animation
1941 Animation animation = Animation::New( 1.0f );
1942 application.SendNotification();
1944 //If PlayRange not specified it should be 0.0-1.0 by default
1945 DALI_TEST_EQUALS( Vector2( 0.0f,1.0f ), animation.GetPlayRange(), TEST_LOCATION );
1947 // Set range between 0.4 and 0.8
1948 animation.SetPlayRange( Vector2( 0.4f, 0.8f ) );
1949 application.SendNotification();
1950 DALI_TEST_EQUALS( Vector2( 0.4f, 0.8f ), animation.GetPlayRange(), TEST_LOCATION );
1955 int UtcDaliAnimationPlayP(void)
1957 TestApplication application;
1959 Actor actor = Actor::New();
1960 Stage::GetCurrent().Add(actor);
1962 // Build the animation
1963 float durationSeconds(1.0f);
1964 Animation animation = Animation::New(durationSeconds);
1965 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1966 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
1968 // Start the animation
1971 bool signalReceived(false);
1972 AnimationFinishCheck finishCheck(signalReceived);
1973 animation.FinishedSignal().Connect(&application, finishCheck);
1975 application.SendNotification();
1976 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
1978 // We didn't expect the animation to finish yet
1979 application.SendNotification();
1980 finishCheck.CheckSignalNotReceived();
1981 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
1983 animation.Play(); // Test that calling play has no effect, when animation is already playing
1984 application.SendNotification();
1985 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
1987 // We didn't expect the animation to finish yet
1988 application.SendNotification();
1989 finishCheck.CheckSignalNotReceived();
1990 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
1992 animation.Play(); // Test that calling play has no effect, when animation is already playing
1993 application.SendNotification();
1994 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
1996 // We didn't expect the animation to finish yet
1997 application.SendNotification();
1998 finishCheck.CheckSignalNotReceived();
1999 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
2001 animation.Play(); // Test that calling play has no effect, when animation is already playing
2002 application.SendNotification();
2003 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
2005 // We didn't expect the animation to finish yet
2006 application.SendNotification();
2007 finishCheck.CheckSignalNotReceived();
2008 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
2010 animation.Play(); // Test that calling play has no effect, when animation is already playing
2011 application.SendNotification();
2012 application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
2014 // We did expect the animation to finish
2015 application.SendNotification();
2016 finishCheck.CheckSignalReceived();
2017 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2019 // Check that nothing has changed after a couple of buffer swaps
2020 application.Render(0);
2021 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2022 application.Render(0);
2023 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2027 int UtcDaliAnimationPlayOffStageP(void)
2029 // Test that an animation can be played, when the actor is off-stage.
2030 // When the actor is added to the stage, it should appear at the current position
2031 // i.e. where it would have been anyway, if on-stage from the beginning.
2033 TestApplication application;
2035 Actor actor = Actor::New();
2036 Vector3 basePosition(Vector3::ZERO);
2037 DALI_TEST_EQUALS( actor.GetCurrentPosition(), basePosition, TEST_LOCATION );
2038 // Not added to the stage!
2040 // Build the animation
2041 float durationSeconds(1.0f);
2042 Animation animation = Animation::New(durationSeconds);
2043 animation.SetDisconnectAction( Animation::Discard );
2044 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2045 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2047 // Start the animation
2050 bool signalReceived(false);
2051 AnimationFinishCheck finishCheck(signalReceived);
2052 animation.FinishedSignal().Connect(&application, finishCheck);
2054 application.SendNotification();
2055 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
2057 // We didn't expect the animation to finish yet
2058 application.SendNotification();
2059 finishCheck.CheckSignalNotReceived();
2060 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*off-stage*/, TEST_LOCATION );
2063 Stage::GetCurrent().Add(actor);
2065 application.SendNotification();
2066 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
2068 // We didn't expect the animation to finish yet
2069 application.SendNotification();
2070 finishCheck.CheckSignalNotReceived();
2071 Vector3 expectedPosition(basePosition + (targetPosition - basePosition)*0.4f);
2072 DALI_TEST_EQUALS( actor.GetCurrentPosition(), expectedPosition/*on-stage*/, TEST_LOCATION );
2074 // Remove from the stage
2075 Stage::GetCurrent().Remove(actor);
2077 application.SendNotification();
2078 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
2080 // We didn't expect the animation to finish yet
2081 application.SendNotification();
2082 finishCheck.CheckSignalNotReceived();
2083 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*back to start position*/, TEST_LOCATION );
2086 Stage::GetCurrent().Add(actor);
2088 application.SendNotification();
2089 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
2091 // We didn't expect the animation to finish yet
2092 application.SendNotification();
2093 finishCheck.CheckSignalNotReceived();
2094 expectedPosition = Vector3(basePosition + (targetPosition - basePosition)*0.8f);
2095 DALI_TEST_EQUALS( actor.GetCurrentPosition(), expectedPosition, TEST_LOCATION );
2097 application.SendNotification();
2098 application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
2100 // We did expect the animation to finish
2101 application.SendNotification();
2102 finishCheck.CheckSignalReceived();
2103 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2105 // Check that nothing has changed after a couple of buffer swaps
2106 application.Render(0);
2107 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2108 application.Render(0);
2109 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2113 int UtcDaliAnimationPlayDiscardHandleP(void)
2115 TestApplication application;
2117 Actor actor = Actor::New();
2118 Stage::GetCurrent().Add(actor);
2120 // Build the animation
2121 float durationSeconds(1.0f);
2122 Animation animation = Animation::New(durationSeconds);
2123 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2124 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2126 bool signalReceived(false);
2127 AnimationFinishCheck finishCheck(signalReceived);
2128 animation.FinishedSignal().Connect(&application, finishCheck);
2130 // Start the animation
2133 // This is a test of the "Fire and Forget" behaviour
2134 // Discard the animation handle!
2136 DALI_TEST_CHECK( !animation );
2138 application.SendNotification();
2139 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
2141 // We didn't expect the animation to finish yet
2142 application.SendNotification();
2143 finishCheck.CheckSignalNotReceived();
2144 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2146 application.SendNotification();
2147 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
2149 // We didn't expect the animation to finish yet
2150 application.SendNotification();
2151 finishCheck.CheckSignalNotReceived();
2152 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
2154 application.SendNotification();
2155 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
2157 // We didn't expect the animation to finish yet
2158 application.SendNotification();
2159 finishCheck.CheckSignalNotReceived();
2160 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
2162 application.SendNotification();
2163 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
2165 // We didn't expect the animation to finish yet
2166 application.SendNotification();
2167 finishCheck.CheckSignalNotReceived();
2168 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
2170 application.SendNotification();
2171 application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
2173 // We did expect the animation to finish
2174 application.SendNotification();
2175 finishCheck.CheckSignalReceived();
2176 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2178 // Check that nothing has changed after a couple of buffer swaps
2179 application.Render(0);
2180 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2181 application.Render(0);
2182 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2186 int UtcDaliAnimationPlayStopDiscardHandleP(void)
2188 TestApplication application;
2190 Actor actor = Actor::New();
2191 Stage::GetCurrent().Add(actor);
2193 // Build the animation
2194 float durationSeconds(1.0f);
2195 Animation animation = Animation::New(durationSeconds);
2196 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2197 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2199 // Start the animation
2202 bool signalReceived(false);
2203 AnimationFinishCheck finishCheck(signalReceived);
2204 animation.FinishedSignal().Connect(&application, finishCheck);
2206 application.SendNotification();
2207 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
2209 // We didn't expect the animation to finish yet
2210 application.SendNotification();
2211 finishCheck.CheckSignalNotReceived();
2212 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2214 // This is a test of the "Fire and Forget" behaviour
2215 // Stop the animation, and Discard the animation handle!
2218 DALI_TEST_CHECK( !animation );
2220 application.SendNotification();
2221 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
2223 // We expect the animation to finish at 20% progress
2224 application.SendNotification();
2225 finishCheck.CheckSignalReceived();
2226 finishCheck.Reset();
2227 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2229 application.SendNotification();
2230 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
2232 // Check that nothing has changed
2233 application.SendNotification();
2234 finishCheck.CheckSignalNotReceived();
2235 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2237 application.SendNotification();
2238 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
2240 // Check that nothing has changed
2241 application.SendNotification();
2242 finishCheck.CheckSignalNotReceived();
2243 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2245 application.SendNotification();
2246 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 100% progress */);
2248 // Check that nothing has changed
2249 application.SendNotification();
2250 finishCheck.CheckSignalNotReceived();
2251 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2255 int UtcDaliAnimationPlayRangeP(void)
2257 TestApplication application;
2259 Actor actor = Actor::New();
2260 Stage::GetCurrent().Add(actor);
2262 // Build the animation
2263 float durationSeconds(1.0f);
2264 Animation animation = Animation::New(durationSeconds);
2265 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2266 KeyFrames keyframes = KeyFrames::New();
2267 keyframes.Add( 0.0f , Vector3(0.0f,0.0f,0.0f ) );
2268 keyframes.Add( 1.0f , Vector3(100.0f,100.0f,100.0f ) );
2270 animation.AnimateBetween( Property( actor, Actor::Property::POSITION), keyframes );
2272 // Set range between 0.4 and 0.8
2273 animation.SetPlayRange( Vector2(0.4f,0.8f) );
2276 bool signalReceived(false);
2277 AnimationFinishCheck finishCheck(signalReceived);
2278 animation.FinishedSignal().Connect(&application, finishCheck);
2280 //Test that setting progress outside the range doesn't work
2281 animation.SetCurrentProgress( 0.9f );
2282 application.SendNotification();
2283 application.Render(0);
2284 DALI_TEST_EQUALS( animation.GetCurrentProgress(), 0.4f, TEST_LOCATION );
2285 animation.SetCurrentProgress( 0.2f );
2286 application.SendNotification();
2287 application.Render(0);
2288 DALI_TEST_EQUALS( animation.GetCurrentProgress(), 0.4f, TEST_LOCATION );
2290 application.SendNotification();
2291 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
2293 // We didn't expect the animation to finish yet
2294 application.SendNotification();
2295 finishCheck.CheckSignalNotReceived();
2296 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
2298 animation.Play(); // Test that calling play has no effect, when animation is already playing
2299 application.SendNotification();
2300 application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/* 80% progress */);
2302 // We did expect the animation to finish
2303 application.SendNotification();
2304 finishCheck.CheckSignalReceived();
2305 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
2307 // Check that nothing has changed after a couple of buffer swaps
2308 application.Render(0);
2309 DALI_TEST_EQUALS( targetPosition * 0.8f, actor.GetCurrentPosition(), TEST_LOCATION );
2310 application.Render(0);
2311 DALI_TEST_EQUALS( targetPosition * 0.8f, actor.GetCurrentPosition(), TEST_LOCATION );
2314 //Loop inside the range
2315 finishCheck.Reset();
2316 animation.SetLooping( true );
2318 application.SendNotification();
2319 float intervalSeconds = 0.1f;
2320 float progress = 0.4f;
2321 for (int iterations = 0; iterations < 10; ++iterations )
2323 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
2325 progress += intervalSeconds;
2326 if (progress > 0.8f)
2328 progress = progress - 0.4f;
2331 DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentPosition(), 0.001f, TEST_LOCATION );
2334 // We didn't expect the animation to finish yet
2335 application.SendNotification();
2336 finishCheck.CheckSignalNotReceived();
2339 //Test change range on the fly
2340 animation.SetPlayRange( Vector2( 0.2f, 0.9f ) );
2341 application.SendNotification();
2343 for (int iterations = 0; iterations < 10; ++iterations )
2345 application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
2347 progress += intervalSeconds;
2348 if (progress > 0.9f)
2350 progress = progress - 0.7f;
2353 DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentPosition(), 0.001f, TEST_LOCATION );
2359 int UtcDaliAnimationPlayFromP(void)
2361 TestApplication application;
2363 Actor actor = Actor::New();
2364 Stage::GetCurrent().Add(actor);
2366 // Build the animation
2367 float durationSeconds(1.0f);
2368 Animation animation = Animation::New(durationSeconds);
2369 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2370 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2372 // Start the animation from 40% progress
2373 animation.PlayFrom( 0.4f );
2375 bool signalReceived(false);
2376 AnimationFinishCheck finishCheck(signalReceived);
2377 animation.FinishedSignal().Connect(&application, finishCheck);
2379 application.SendNotification();
2380 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
2382 // We didn't expect the animation to finish yet
2383 application.SendNotification();
2384 finishCheck.CheckSignalNotReceived();
2385 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
2387 animation.Play(); // Test that calling play has no effect, when animation is already playing
2388 application.SendNotification();
2389 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
2391 // We didn't expect the animation to finish yet
2392 application.SendNotification();
2393 finishCheck.CheckSignalNotReceived();
2394 DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
2396 application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
2397 // We did expect the animation to finish
2398 application.SendNotification();
2399 finishCheck.CheckSignalReceived();
2400 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2402 // Check that nothing has changed after a couple of buffer swaps
2403 application.Render(0);
2404 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2405 application.Render(0);
2406 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2410 int UtcDaliAnimationPlayFromN(void)
2412 TestApplication application;
2414 Actor actor = Actor::New();
2415 Stage::GetCurrent().Add(actor);
2417 // Build the animation
2418 float durationSeconds(1.0f);
2419 Animation animation = Animation::New(durationSeconds);
2420 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2421 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2423 //PlayFrom with an argument outside the range [0..1] will be ignored
2424 animation.PlayFrom(-1.0f);
2425 application.SendNotification();
2426 DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
2428 animation.PlayFrom(100.0f);
2429 application.SendNotification();
2430 DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
2434 int UtcDaliAnimationPauseP(void)
2436 TestApplication application;
2438 Actor actor = Actor::New();
2439 Stage::GetCurrent().Add(actor);
2441 // Build the animation
2442 float durationSeconds(1.0f);
2443 Animation animation = Animation::New(durationSeconds);
2444 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2445 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2447 Vector3 fiftyPercentProgress(targetPosition * 0.5f);
2449 // Start the animation
2452 bool signalReceived(false);
2453 AnimationFinishCheck finishCheck(signalReceived);
2454 animation.FinishedSignal().Connect(&application, finishCheck);
2456 application.SendNotification();
2457 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2459 // We didn't expect the animation to finish yet
2460 application.SendNotification();
2461 finishCheck.CheckSignalNotReceived();
2462 DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
2464 // Pause the animation
2466 application.SendNotification();
2469 for (int i=0; i<5; ++i)
2471 application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
2473 // We didn't expect the animation to finish yet
2474 application.SendNotification();
2475 finishCheck.CheckSignalNotReceived();
2476 DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress/* Still 50% progress when paused */, TEST_LOCATION );
2481 application.SendNotification();
2482 application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
2484 // We didn't expect the animation to finish yet
2485 application.SendNotification();
2486 finishCheck.CheckSignalNotReceived();
2488 application.SendNotification();
2489 application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
2491 // We did expect the animation to finish
2492 application.SendNotification();
2493 finishCheck.CheckSignalReceived();
2494 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2496 // Check that nothing has changed after a couple of buffer swaps
2497 application.Render(0);
2498 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2499 application.Render(0);
2500 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2505 int UtcDaliAnimationGetStateP(void)
2507 TestApplication application;
2509 Actor actor = Actor::New();
2510 Stage::GetCurrent().Add(actor);
2512 // Build the animation
2513 float durationSeconds(1.0f);
2514 Animation animation = Animation::New(durationSeconds);
2515 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2516 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2517 DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
2519 Vector3 fiftyPercentProgress(targetPosition * 0.5f);
2521 // Start the animation
2524 DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2526 bool signalReceived(false);
2527 AnimationFinishCheck finishCheck(signalReceived);
2528 animation.FinishedSignal().Connect(&application, finishCheck);
2530 application.SendNotification();
2531 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2533 // We didn't expect the animation to finish yet
2534 application.SendNotification();
2535 finishCheck.CheckSignalNotReceived();
2536 DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2537 DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
2539 // Pause the animation
2541 DALI_TEST_EQUALS( animation.GetState(), Animation::PAUSED, TEST_LOCATION );
2542 application.SendNotification();
2543 application.Render(0.f);
2546 for (int i=0; i<5; ++i)
2548 application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
2550 // We didn't expect the animation to finish yet
2551 application.SendNotification();
2552 finishCheck.CheckSignalNotReceived();
2553 DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress/* Still 50% progress when paused */, TEST_LOCATION );
2554 DALI_TEST_EQUALS( animation.GetState(), Animation::PAUSED, TEST_LOCATION );
2558 finishCheck.Reset();
2560 DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2561 application.SendNotification();
2562 application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
2563 // We didn't expect the animation to finish yet
2564 application.SendNotification();
2565 finishCheck.CheckSignalNotReceived();
2566 DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2568 application.SendNotification();
2569 application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
2571 // We did expect the animation to finish
2572 application.SendNotification();
2573 finishCheck.CheckSignalReceived();
2574 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2575 DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
2577 // Check that nothing has changed after a couple of buffer swaps
2578 application.Render(0);
2579 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2580 application.Render(0);
2581 DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2582 DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
2585 finishCheck.Reset();
2587 DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2588 application.SendNotification();
2589 application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
2590 application.SendNotification();
2591 finishCheck.CheckSignalNotReceived();
2592 DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2598 int UtcDaliAnimationStopP(void)
2600 TestApplication application;
2602 Actor actor = Actor::New();
2603 Stage::GetCurrent().Add(actor);
2605 // Build the animation
2606 float durationSeconds(1.0f);
2607 Animation animation = Animation::New(durationSeconds);
2608 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2609 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2611 Vector3 fiftyPercentProgress(targetPosition * 0.5f);
2613 // Start the animation
2616 bool signalReceived(false);
2617 AnimationFinishCheck finishCheck(signalReceived);
2618 animation.FinishedSignal().Connect(&application, finishCheck);
2620 application.SendNotification();
2621 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2623 // We didn't expect the animation to finish yet
2624 application.SendNotification();
2625 finishCheck.CheckSignalNotReceived();
2626 DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
2628 // Stop the animation
2630 application.SendNotification();
2633 for (int i=0; i<5; ++i)
2635 application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
2637 // We did expect the animation to finish
2638 application.SendNotification();
2639 finishCheck.CheckSignalReceived();
2640 DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress/* Still 50% progress when stopped */, TEST_LOCATION );
2645 int UtcDaliAnimationStopSetPositionP(void)
2647 // Test that Animation::Stop & Actor::SetPosition can be used in conjunction
2648 // i.e. to check that the animation does not interfere with the position set.
2650 TestApplication application;
2652 Actor actor = Actor::New();
2653 Stage::GetCurrent().Add(actor);
2655 // Build the animation
2656 float durationSeconds(1.0f);
2657 Animation animation = Animation::New(durationSeconds);
2658 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2659 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2661 Vector3 fiftyPercentProgress(targetPosition * 0.5f);
2663 // Start the animation
2666 bool signalReceived(false);
2667 AnimationFinishCheck finishCheck(signalReceived);
2668 animation.FinishedSignal().Connect(&application, finishCheck);
2670 application.SendNotification();
2671 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2673 // We didn't expect the animation to finish yet
2674 application.SendNotification();
2675 finishCheck.CheckSignalNotReceived();
2676 DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
2678 // Stop the animation
2680 Vector3 positionSet(2.0f, 3.0f, 4.0f);
2681 actor.SetPosition(positionSet);
2682 application.SendNotification();
2685 for (int i=0; i<5; ++i)
2687 application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
2689 // We did expect the animation to finish
2690 application.SendNotification();
2691 finishCheck.CheckSignalReceived();
2692 DALI_TEST_EQUALS( actor.GetCurrentPosition(), positionSet/*Animation should not interfere with this*/, TEST_LOCATION );
2697 int UtcDaliAnimationClearP(void)
2699 TestApplication application;
2701 Actor actor = Actor::New();
2702 Stage::GetCurrent().Add(actor);
2704 // Build the animation
2705 float durationSeconds(1.0f);
2706 Animation animation = Animation::New(durationSeconds);
2707 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2708 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2710 Vector3 fiftyPercentProgress(targetPosition * 0.5f);
2712 // Start the animation
2715 bool signalReceived(false);
2716 AnimationFinishCheck finishCheck(signalReceived);
2717 animation.FinishedSignal().Connect(&application, finishCheck);
2719 application.SendNotification();
2720 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2722 // We didn't expect the animation to finish yet
2723 application.SendNotification();
2724 finishCheck.CheckSignalNotReceived();
2725 DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
2727 // Clear the animation
2729 application.SendNotification();
2731 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
2733 // We don't expect the animation to finish now
2734 application.SendNotification();
2735 finishCheck.CheckSignalNotReceived();
2736 DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress/* Still 50% progress since the animator was destroyed */, TEST_LOCATION );
2738 // Restart as a scale animation; this should not move the actor's position
2739 finishCheck.Reset();
2740 actor.SetPosition(Vector3::ZERO);
2741 Vector3 targetScale(3.0f, 3.0f, 3.0f);
2742 animation.AnimateTo( Property( actor, Actor::Property::SCALE ), targetScale, AlphaFunction::LINEAR );
2745 application.SendNotification();
2746 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2748 // We didn't expect the animation to finish yet
2749 application.SendNotification();
2750 finishCheck.CheckSignalNotReceived();
2751 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*Check move-animator was destroyed*/, TEST_LOCATION );
2752 DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3(2.0f, 2.0f, 2.0f), TEST_LOCATION );
2754 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
2756 // We did expect the animation to finish
2757 application.SendNotification();
2758 finishCheck.CheckSignalReceived();
2759 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*Check move-animator was destroyed*/, TEST_LOCATION );
2760 DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
2764 int UtcDaliAnimationFinishedSignalP(void)
2766 TestApplication application;
2768 // Start the empty animation
2769 float durationSeconds(1.0f);
2770 Animation animation = Animation::New(durationSeconds);
2773 bool signalReceived(false);
2774 AnimationFinishCheck finishCheck(signalReceived);
2775 animation.FinishedSignal().Connect(&application, finishCheck);
2777 application.SendNotification();
2778 application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*beyond the animation duration*/);
2780 // We did expect the animation to finish
2781 application.SendNotification();
2782 finishCheck.CheckSignalReceived();
2786 int UtcDaliAnimationAnimateByBooleanP(void)
2788 TestApplication application;
2790 Actor actor = Actor::New();
2792 // Register a boolean property
2793 bool startValue(false);
2794 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
2795 Stage::GetCurrent().Add(actor);
2796 DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
2797 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2799 // Build the animation
2800 float durationSeconds(2.0f);
2801 Animation animation = Animation::New(durationSeconds);
2802 const bool relativeValue(true);
2803 const bool finalValue( false || relativeValue );
2804 animation.AnimateBy(Property(actor, index), relativeValue);
2806 // Start the animation
2809 bool signalReceived(false);
2810 AnimationFinishCheck finishCheck(signalReceived);
2811 animation.FinishedSignal().Connect(&application, finishCheck);
2813 application.SendNotification();
2814 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
2816 // We didn't expect the animation to finish yet
2817 application.SendNotification();
2818 finishCheck.CheckSignalNotReceived();
2819 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2821 application.SendNotification();
2822 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
2824 // We did expect the animation to finish
2825 application.SendNotification();
2826 finishCheck.CheckSignalReceived();
2827 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2829 // Check that nothing has changed after a couple of buffer swaps
2830 application.Render(0);
2831 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2832 application.Render(0);
2833 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2835 // Repeat with relative value "false" - this should be an NOOP
2836 animation = Animation::New(durationSeconds);
2837 bool noOpValue(false);
2838 animation.AnimateBy(Property(actor, index), noOpValue);
2840 // Start the animation
2843 finishCheck.Reset();
2844 animation.FinishedSignal().Connect(&application, finishCheck);
2846 application.SendNotification();
2847 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
2849 // We didn't expect the animation to finish yet
2850 application.SendNotification();
2851 finishCheck.CheckSignalNotReceived();
2852 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2854 application.SendNotification();
2855 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
2857 // We did expect the animation to finish
2858 application.SendNotification();
2859 finishCheck.CheckSignalReceived();
2860 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2862 // Check that nothing has changed after a couple of buffer swaps
2863 application.Render(0);
2864 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2865 application.Render(0);
2866 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2870 int UtcDaliAnimationAnimateByBooleanAlphaFunctionP(void)
2872 TestApplication application;
2874 Actor actor = Actor::New();
2876 // Register a boolean property
2877 bool startValue(false);
2878 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
2879 Stage::GetCurrent().Add(actor);
2880 DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
2881 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2883 // Build the animation
2884 float durationSeconds(2.0f);
2885 Animation animation = Animation::New(durationSeconds);
2886 bool relativeValue(true);
2887 bool finalValue( false || relativeValue );
2888 animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_IN);
2890 // Start the animation
2893 bool signalReceived(false);
2894 AnimationFinishCheck finishCheck(signalReceived);
2895 animation.FinishedSignal().Connect(&application, finishCheck);
2897 application.SendNotification();
2898 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
2900 // We didn't expect the animation to finish yet
2901 application.SendNotification();
2902 finishCheck.CheckSignalNotReceived();
2903 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2905 application.SendNotification();
2906 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
2908 // We did expect the animation to finish
2909 application.SendNotification();
2910 finishCheck.CheckSignalReceived();
2911 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2913 // Check that nothing has changed after a couple of buffer swaps
2914 application.Render(0);
2915 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2916 application.Render(0);
2917 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2919 // Repeat with relative value "false" - this should be an NOOP
2920 animation = Animation::New(durationSeconds);
2921 bool noOpValue(false);
2922 animation.AnimateBy(Property(actor, index), noOpValue, AlphaFunction::EASE_IN);
2924 // Start the animation
2927 finishCheck.Reset();
2928 animation.FinishedSignal().Connect(&application, finishCheck);
2930 application.SendNotification();
2931 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
2933 // We didn't expect the animation to finish yet
2934 application.SendNotification();
2935 finishCheck.CheckSignalNotReceived();
2936 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2938 application.SendNotification();
2939 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
2941 // We did expect the animation to finish
2942 application.SendNotification();
2943 finishCheck.CheckSignalReceived();
2944 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2948 int UtcDaliAnimationAnimateByBooleanTimePeriodP(void)
2950 TestApplication application;
2952 Actor actor = Actor::New();
2954 // Register a boolean property
2955 bool startValue(false);
2956 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
2957 Stage::GetCurrent().Add(actor);
2958 DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
2959 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2961 // Build the animation
2962 float durationSeconds(2.0f);
2963 Animation animation = Animation::New(durationSeconds);
2964 bool relativeValue(true);
2965 bool finalValue( false || relativeValue );
2966 float animatorDurationSeconds(durationSeconds * 0.5f);
2967 animation.AnimateBy( Property(actor, index),
2969 TimePeriod( animatorDurationSeconds ) );
2971 // Start the animation
2974 bool signalReceived(false);
2975 AnimationFinishCheck finishCheck(signalReceived);
2976 animation.FinishedSignal().Connect(&application, finishCheck);
2978 application.SendNotification();
2979 application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
2981 // We didn't expect the animation to finish yet
2982 application.SendNotification();
2983 finishCheck.CheckSignalNotReceived();
2984 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2986 application.SendNotification();
2987 application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
2989 // We didn't expect the animation to finish yet...
2990 application.SendNotification();
2991 finishCheck.CheckSignalNotReceived();
2993 // ...however we should have reached the final value
2994 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2996 application.SendNotification();
2997 application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
2999 // We did expect the animation to finish
3000 application.SendNotification();
3001 finishCheck.CheckSignalReceived();
3002 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3004 // Check that nothing has changed after a couple of buffer swaps
3005 application.Render(0);
3006 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3007 application.Render(0);
3008 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3012 int UtcDaliAnimationAnimateByBooleanAlphaFunctionTimePeriodP(void)
3014 TestApplication application;
3016 Actor actor = Actor::New();
3018 // Register a boolean property
3019 bool startValue(false);
3020 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3021 Stage::GetCurrent().Add(actor);
3022 DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
3023 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
3025 // Build the animation
3026 float durationSeconds(2.0f);
3027 Animation animation = Animation::New(durationSeconds);
3028 bool relativeValue(true);
3029 bool finalValue( false || relativeValue );
3030 float animatorDurationSeconds(durationSeconds * 0.5f);
3031 animation.AnimateBy( Property(actor, index),
3033 AlphaFunction::EASE_IN_OUT,
3034 TimePeriod( animatorDurationSeconds ) );
3036 // Start the animation
3039 bool signalReceived(false);
3040 AnimationFinishCheck finishCheck(signalReceived);
3041 animation.FinishedSignal().Connect(&application, finishCheck);
3043 application.SendNotification();
3044 application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
3046 // We didn't expect the animation to finish yet
3047 application.SendNotification();
3048 finishCheck.CheckSignalNotReceived();
3049 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
3051 application.SendNotification();
3052 application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
3054 // We didn't expect the animation to finish yet...
3055 application.SendNotification();
3056 finishCheck.CheckSignalNotReceived();
3058 // ...however we should have reached the final value
3059 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3061 application.SendNotification();
3062 application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
3064 // We did expect the animation to finish
3065 application.SendNotification();
3066 finishCheck.CheckSignalReceived();
3067 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3069 // Check that nothing has changed after a couple of buffer swaps
3070 application.Render(0);
3071 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3072 application.Render(0);
3073 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3077 int UtcDaliAnimationAnimateByFloatP(void)
3079 TestApplication application;
3081 Actor actor = Actor::New();
3083 // Register a float property
3084 float startValue(10.0f);
3085 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3086 Stage::GetCurrent().Add(actor);
3087 DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
3088 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3090 // Build the animation
3091 float durationSeconds(2.0f);
3092 Animation animation = Animation::New(durationSeconds);
3093 float targetValue(50.0f);
3094 float relativeValue(targetValue - startValue);
3095 animation.AnimateBy(Property(actor, index), relativeValue);
3097 float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3099 // Start the animation
3102 bool signalReceived(false);
3103 AnimationFinishCheck finishCheck(signalReceived);
3104 animation.FinishedSignal().Connect(&application, finishCheck);
3106 application.SendNotification();
3107 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3109 // We didn't expect the animation to finish yet
3110 application.SendNotification();
3111 finishCheck.CheckSignalNotReceived();
3112 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
3114 application.SendNotification();
3115 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3117 // We did expect the animation to finish
3118 application.SendNotification();
3119 finishCheck.CheckSignalReceived();
3120 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3122 // Check that nothing has changed after a couple of buffer swaps
3123 application.Render(0);
3124 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3125 application.Render(0);
3126 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3130 int UtcDaliAnimationAnimateByFloatAlphaFunctionP(void)
3132 TestApplication application;
3134 Actor actor = Actor::New();
3136 // Register a float property
3137 float startValue(10.0f);
3138 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3139 Stage::GetCurrent().Add(actor);
3140 DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
3141 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3143 // Build the animation
3144 float durationSeconds(1.0f);
3145 Animation animation = Animation::New(durationSeconds);
3146 float targetValue(90.0f);
3147 float relativeValue(targetValue - startValue);
3148 animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
3150 float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3152 // Start the animation
3155 bool signalReceived(false);
3156 AnimationFinishCheck finishCheck(signalReceived);
3157 animation.FinishedSignal().Connect(&application, finishCheck);
3159 application.SendNotification();
3160 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3162 // We didn't expect the animation to finish yet
3163 application.SendNotification();
3164 finishCheck.CheckSignalNotReceived();
3166 // The position should have moved more, than with a linear alpha function
3167 float current( DevelHandle::GetCurrentProperty< float >( actor, index ) );
3168 DALI_TEST_CHECK( current > ninetyFivePercentProgress );
3170 application.SendNotification();
3171 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3173 // We did expect the animation to finish
3174 application.SendNotification();
3175 finishCheck.CheckSignalReceived();
3176 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3178 // Check that nothing has changed after a couple of buffer swaps
3179 application.Render(0);
3180 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3181 application.Render(0);
3182 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3186 int UtcDaliAnimationAnimateByFloatTimePeriodP(void)
3188 TestApplication application;
3190 Actor actor = Actor::New();
3192 // Register a float property
3193 float startValue(10.0f);
3194 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3195 Stage::GetCurrent().Add(actor);
3196 DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
3197 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3199 // Build the animation
3200 float durationSeconds(1.0f);
3201 Animation animation = Animation::New(durationSeconds);
3202 float targetValue(30.0f);
3203 float relativeValue(targetValue - startValue);
3205 animation.AnimateBy(Property(actor, index),
3207 TimePeriod(delay, durationSeconds - delay));
3209 // Start the animation
3212 bool signalReceived(false);
3213 AnimationFinishCheck finishCheck(signalReceived);
3214 animation.FinishedSignal().Connect(&application, finishCheck);
3216 application.SendNotification();
3217 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3219 // We didn't expect the animation to finish yet
3220 application.SendNotification();
3221 finishCheck.CheckSignalNotReceived();
3222 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3224 application.SendNotification();
3225 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3227 // We didn't expect the animation to finish yet
3228 application.SendNotification();
3229 finishCheck.CheckSignalNotReceived();
3230 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3232 application.SendNotification();
3233 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3235 // We did expect the animation to finish
3236 application.SendNotification();
3237 finishCheck.CheckSignalReceived();
3238 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3240 // Check that nothing has changed after a couple of buffer swaps
3241 application.Render(0);
3242 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3243 application.Render(0);
3244 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3248 int UtcDaliAnimationAnimateByFloatAlphaFunctionTimePeriodP(void)
3250 TestApplication application;
3252 Actor actor = Actor::New();
3254 // Register a float property
3255 float startValue(10.0f);
3256 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3257 Stage::GetCurrent().Add(actor);
3258 DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
3259 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3261 // Build the animation
3262 float durationSeconds(1.0f);
3263 Animation animation = Animation::New(durationSeconds);
3264 float targetValue(30.0f);
3265 float relativeValue(targetValue - startValue);
3267 animation.AnimateBy(Property(actor, index),
3269 AlphaFunction::LINEAR,
3270 TimePeriod(delay, durationSeconds - delay));
3272 // Start the animation
3275 bool signalReceived(false);
3276 AnimationFinishCheck finishCheck(signalReceived);
3277 animation.FinishedSignal().Connect(&application, finishCheck);
3279 application.SendNotification();
3280 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3282 // We didn't expect the animation to finish yet
3283 application.SendNotification();
3284 finishCheck.CheckSignalNotReceived();
3285 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3287 application.SendNotification();
3288 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3290 // We didn't expect the animation to finish yet
3291 application.SendNotification();
3292 finishCheck.CheckSignalNotReceived();
3293 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3295 application.SendNotification();
3296 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3298 // We did expect the animation to finish
3299 application.SendNotification();
3300 finishCheck.CheckSignalReceived();
3301 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3303 // Check that nothing has changed after a couple of buffer swaps
3304 application.Render(0);
3305 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3306 application.Render(0);
3307 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3311 int UtcDaliAnimationAnimateByIntegerP(void)
3313 TestApplication application;
3315 Actor actor = Actor::New();
3317 // Register an integer property
3319 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3320 Stage::GetCurrent().Add(actor);
3321 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
3322 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3324 // Build the animation
3325 float durationSeconds(2.0f);
3326 Animation animation = Animation::New(durationSeconds);
3327 int targetValue(50);
3328 int relativeValue(targetValue - startValue);
3329 animation.AnimateBy(Property(actor, index), relativeValue);
3331 int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
3333 // Start the animation
3336 bool signalReceived(false);
3337 AnimationFinishCheck finishCheck(signalReceived);
3338 animation.FinishedSignal().Connect(&application, finishCheck);
3340 application.SendNotification();
3341 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3343 // We didn't expect the animation to finish yet
3344 application.SendNotification();
3345 finishCheck.CheckSignalNotReceived();
3346 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
3348 application.SendNotification();
3349 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3351 // We did expect the animation to finish
3352 application.SendNotification();
3353 finishCheck.CheckSignalReceived();
3354 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3356 // Check that nothing has changed after a couple of buffer swaps
3357 application.Render(0);
3358 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3359 application.Render(0);
3360 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3364 int UtcDaliAnimationAnimateByIntegerAlphaFunctionP(void)
3366 TestApplication application;
3368 Actor actor = Actor::New();
3370 // Register an integer property
3372 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3373 Stage::GetCurrent().Add(actor);
3374 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
3375 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3377 // Build the animation
3378 float durationSeconds(1.0f);
3379 Animation animation = Animation::New(durationSeconds);
3380 int targetValue(90);
3381 int relativeValue(targetValue - startValue);
3382 animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
3384 int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
3386 // Start the animation
3389 bool signalReceived(false);
3390 AnimationFinishCheck finishCheck(signalReceived);
3391 animation.FinishedSignal().Connect(&application, finishCheck);
3393 application.SendNotification();
3394 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3396 // We didn't expect the animation to finish yet
3397 application.SendNotification();
3398 finishCheck.CheckSignalNotReceived();
3400 // The position should have moved more, than with a linear alpha function
3401 int current( DevelHandle::GetCurrentProperty< int >( actor, index ) );
3402 DALI_TEST_CHECK( current > ninetyFivePercentProgress );
3404 application.SendNotification();
3405 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3407 // We did expect the animation to finish
3408 application.SendNotification();
3409 finishCheck.CheckSignalReceived();
3410 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3412 // Check that nothing has changed after a couple of buffer swaps
3413 application.Render(0);
3414 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3415 application.Render(0);
3416 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3420 int UtcDaliAnimationAnimateByIntegerTimePeriodP(void)
3422 TestApplication application;
3424 Actor actor = Actor::New();
3426 // Register an integer property
3428 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3429 Stage::GetCurrent().Add(actor);
3430 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
3431 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3433 // Build the animation
3434 float durationSeconds(1.0f);
3435 Animation animation = Animation::New(durationSeconds);
3436 int targetValue(30);
3437 int relativeValue(targetValue - startValue);
3439 animation.AnimateBy(Property(actor, index),
3441 TimePeriod(delay, durationSeconds - delay));
3443 // Start the animation
3446 bool signalReceived(false);
3447 AnimationFinishCheck finishCheck(signalReceived);
3448 animation.FinishedSignal().Connect(&application, finishCheck);
3450 application.SendNotification();
3451 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3453 // We didn't expect the animation to finish yet
3454 application.SendNotification();
3455 finishCheck.CheckSignalNotReceived();
3456 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3458 application.SendNotification();
3459 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3461 // We didn't expect the animation to finish yet
3462 application.SendNotification();
3463 finishCheck.CheckSignalNotReceived();
3464 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
3466 application.SendNotification();
3467 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3469 // We did expect the animation to finish
3470 application.SendNotification();
3471 finishCheck.CheckSignalReceived();
3472 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3474 // Check that nothing has changed after a couple of buffer swaps
3475 application.Render(0);
3476 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3477 application.Render(0);
3478 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3482 int UtcDaliAnimationAnimateByIntegerAlphaFunctionTimePeriodP(void)
3484 TestApplication application;
3486 Actor actor = Actor::New();
3488 // Register an integer property
3490 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3491 Stage::GetCurrent().Add(actor);
3492 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
3493 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3495 // Build the animation
3496 float durationSeconds(1.0f);
3497 Animation animation = Animation::New(durationSeconds);
3498 int targetValue(30);
3499 int relativeValue(targetValue - startValue);
3501 animation.AnimateBy(Property(actor, index),
3503 AlphaFunction::LINEAR,
3504 TimePeriod(delay, durationSeconds - delay));
3506 // Start the animation
3509 bool signalReceived(false);
3510 AnimationFinishCheck finishCheck(signalReceived);
3511 animation.FinishedSignal().Connect(&application, finishCheck);
3513 application.SendNotification();
3514 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3516 // We didn't expect the animation to finish yet
3517 application.SendNotification();
3518 finishCheck.CheckSignalNotReceived();
3519 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3521 application.SendNotification();
3522 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3524 // We didn't expect the animation to finish yet
3525 application.SendNotification();
3526 finishCheck.CheckSignalNotReceived();
3527 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
3529 application.SendNotification();
3530 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3532 // We did expect the animation to finish
3533 application.SendNotification();
3534 finishCheck.CheckSignalReceived();
3535 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3537 // Check that nothing has changed after a couple of buffer swaps
3538 application.Render(0);
3539 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3540 application.Render(0);
3541 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3545 int UtcDaliAnimationAnimateByVector2P(void)
3547 TestApplication application;
3549 Actor actor = Actor::New();
3551 // Register a Vector2 property
3552 Vector2 startValue(10.0f, 10.0f);
3553 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3554 Stage::GetCurrent().Add(actor);
3555 DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
3556 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3558 // Build the animation
3559 float durationSeconds(2.0f);
3560 Animation animation = Animation::New(durationSeconds);
3561 Vector2 targetValue(60.0f, 60.0f);
3562 Vector2 relativeValue(targetValue - startValue);
3563 animation.AnimateBy(Property(actor, index), relativeValue);
3565 Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3567 // Start the animation
3570 bool signalReceived(false);
3571 AnimationFinishCheck finishCheck(signalReceived);
3572 animation.FinishedSignal().Connect(&application, finishCheck);
3574 application.SendNotification();
3575 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3577 // We didn't expect the animation to finish yet
3578 application.SendNotification();
3579 finishCheck.CheckSignalNotReceived();
3580 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
3582 application.SendNotification();
3583 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3585 // We did expect the animation to finish
3586 application.SendNotification();
3587 finishCheck.CheckSignalReceived();
3588 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3590 // Check that nothing has changed after a couple of buffer swaps
3591 application.Render(0);
3592 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3593 application.Render(0);
3594 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3598 int UtcDaliAnimationAnimateByVector2AlphaFunctionP(void)
3600 TestApplication application;
3602 Actor actor = Actor::New();
3604 // Register a Vector2 property
3605 Vector2 startValue(100.0f, 100.0f);
3606 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3607 Stage::GetCurrent().Add(actor);
3608 DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
3609 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3611 // Build the animation
3612 float durationSeconds(1.0f);
3613 Animation animation = Animation::New(durationSeconds);
3614 Vector2 targetValue(20.0f, 20.0f);
3615 Vector2 relativeValue(targetValue - startValue);
3616 animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
3618 Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3620 // Start the animation
3623 bool signalReceived(false);
3624 AnimationFinishCheck finishCheck(signalReceived);
3625 animation.FinishedSignal().Connect(&application, finishCheck);
3627 application.SendNotification();
3628 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3630 // We didn't expect the animation to finish yet
3631 application.SendNotification();
3632 finishCheck.CheckSignalNotReceived();
3634 // The position should have moved more, than with a linear alpha function
3635 Vector2 current( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ) );
3636 DALI_TEST_CHECK( current.x < ninetyFivePercentProgress.x );
3637 DALI_TEST_CHECK( current.y < ninetyFivePercentProgress.y );
3639 application.SendNotification();
3640 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3642 // We did expect the animation to finish
3643 application.SendNotification();
3644 finishCheck.CheckSignalReceived();
3645 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3647 // Check that nothing has changed after a couple of buffer swaps
3648 application.Render(0);
3649 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3650 application.Render(0);
3651 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3655 int UtcDaliAnimationAnimateByVector2TimePeriodP(void)
3657 TestApplication application;
3659 Actor actor = Actor::New();
3661 // Register a Vector2 property
3662 Vector2 startValue(10.0f, 10.0f);
3663 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3664 Stage::GetCurrent().Add(actor);
3665 DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
3666 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3668 // Build the animation
3669 float durationSeconds(1.0f);
3670 Animation animation = Animation::New(durationSeconds);
3671 Vector2 targetValue(30.0f, 30.0f);
3672 Vector2 relativeValue(targetValue - startValue);
3674 animation.AnimateBy(Property(actor, index),
3676 TimePeriod(delay, durationSeconds - delay));
3678 // Start the animation
3681 bool signalReceived(false);
3682 AnimationFinishCheck finishCheck(signalReceived);
3683 animation.FinishedSignal().Connect(&application, finishCheck);
3685 application.SendNotification();
3686 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3688 // We didn't expect the animation to finish yet
3689 application.SendNotification();
3690 finishCheck.CheckSignalNotReceived();
3691 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3693 application.SendNotification();
3694 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3696 // We didn't expect the animation to finish yet
3697 application.SendNotification();
3698 finishCheck.CheckSignalNotReceived();
3699 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3701 application.SendNotification();
3702 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3704 // We did expect the animation to finish
3705 application.SendNotification();
3706 finishCheck.CheckSignalReceived();
3707 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3709 // Check that nothing has changed after a couple of buffer swaps
3710 application.Render(0);
3711 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3712 application.Render(0);
3713 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3717 int UtcDaliAnimationAnimateByVector2AlphaFunctionTimePeriodP(void)
3719 TestApplication application;
3721 Actor actor = Actor::New();
3723 // Register a Vector2 property
3724 Vector2 startValue(5.0f, 5.0f);
3725 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3726 Stage::GetCurrent().Add(actor);
3727 DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
3728 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3730 // Build the animation
3731 float durationSeconds(1.0f);
3732 Animation animation = Animation::New(durationSeconds);
3733 Vector2 targetValue(10.0f, 10.0f);
3734 Vector2 relativeValue(targetValue - startValue);
3736 animation.AnimateBy(Property(actor, index),
3738 AlphaFunction::LINEAR,
3739 TimePeriod(delay, durationSeconds - delay));
3741 // Start the animation
3744 bool signalReceived(false);
3745 AnimationFinishCheck finishCheck(signalReceived);
3746 animation.FinishedSignal().Connect(&application, finishCheck);
3748 application.SendNotification();
3749 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3751 // We didn't expect the animation to finish yet
3752 application.SendNotification();
3753 finishCheck.CheckSignalNotReceived();
3754 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3756 application.SendNotification();
3757 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3759 // We didn't expect the animation to finish yet
3760 application.SendNotification();
3761 finishCheck.CheckSignalNotReceived();
3762 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3764 application.SendNotification();
3765 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3767 // We did expect the animation to finish
3768 application.SendNotification();
3769 finishCheck.CheckSignalReceived();
3770 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3772 // Check that nothing has changed after a couple of buffer swaps
3773 application.Render(0);
3774 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3775 application.Render(0);
3776 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3780 int UtcDaliAnimationAnimateByVector3P(void)
3782 TestApplication application;
3784 Actor actor = Actor::New();
3786 // Register a Vector3 property
3787 Vector3 startValue(10.0f, 10.0f, 10.0f);
3788 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3789 Stage::GetCurrent().Add(actor);
3790 DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
3791 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3793 // Build the animation
3794 float durationSeconds(2.0f);
3795 Animation animation = Animation::New(durationSeconds);
3796 Vector3 targetValue(60.0f, 60.0f, 60.0f);
3797 Vector3 relativeValue(targetValue - startValue);
3798 animation.AnimateBy(Property(actor, index), relativeValue);
3800 Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3802 // Start the animation
3805 bool signalReceived(false);
3806 AnimationFinishCheck finishCheck(signalReceived);
3807 animation.FinishedSignal().Connect(&application, finishCheck);
3809 application.SendNotification();
3810 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3812 // We didn't expect the animation to finish yet
3813 application.SendNotification();
3814 finishCheck.CheckSignalNotReceived();
3815 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
3817 application.SendNotification();
3818 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3820 // We did expect the animation to finish
3821 application.SendNotification();
3822 finishCheck.CheckSignalReceived();
3823 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3825 // Check that nothing has changed after a couple of buffer swaps
3826 application.Render(0);
3827 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3828 application.Render(0);
3829 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3833 int UtcDaliAnimationAnimateByVector3AlphaFunctionP(void)
3835 TestApplication application;
3837 Actor actor = Actor::New();
3839 // Register a Vector3 property
3840 Vector3 startValue(100.0f, 100.0f, 100.0f);
3841 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3842 Stage::GetCurrent().Add(actor);
3843 DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
3844 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3846 // Build the animation
3847 float durationSeconds(1.0f);
3848 Animation animation = Animation::New(durationSeconds);
3849 Vector3 targetValue(20.0f, 20.0f, 20.0f);
3850 Vector3 relativeValue(targetValue - startValue);
3851 animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
3853 Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3855 // Start the animation
3858 bool signalReceived(false);
3859 AnimationFinishCheck finishCheck(signalReceived);
3860 animation.FinishedSignal().Connect(&application, finishCheck);
3862 application.SendNotification();
3863 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3865 // We didn't expect the animation to finish yet
3866 application.SendNotification();
3867 finishCheck.CheckSignalNotReceived();
3869 // The position should have moved more, than with a linear alpha function
3870 Vector3 current(DevelHandle::GetCurrentProperty< Vector3 >( actor, index ));
3871 DALI_TEST_CHECK( current.x < ninetyFivePercentProgress.x );
3872 DALI_TEST_CHECK( current.y < ninetyFivePercentProgress.y );
3873 DALI_TEST_CHECK( current.z < ninetyFivePercentProgress.z );
3875 application.SendNotification();
3876 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3878 // We did expect the animation to finish
3879 application.SendNotification();
3880 finishCheck.CheckSignalReceived();
3881 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3883 // Check that nothing has changed after a couple of buffer swaps
3884 application.Render(0);
3885 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3886 application.Render(0);
3887 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3891 int UtcDaliAnimationAnimateByVector3TimePeriodP(void)
3893 TestApplication application;
3895 Actor actor = Actor::New();
3897 // Register a Vector3 property
3898 Vector3 startValue(10.0f, 10.0f, 10.0f);
3899 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3900 Stage::GetCurrent().Add(actor);
3901 DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
3902 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3904 // Build the animation
3905 float durationSeconds(1.0f);
3906 Animation animation = Animation::New(durationSeconds);
3907 Vector3 targetValue(30.0f, 30.0f, 30.0f);
3908 Vector3 relativeValue(targetValue - startValue);
3910 animation.AnimateBy(Property(actor, index),
3912 TimePeriod(delay, durationSeconds - delay));
3914 // Start the animation
3917 bool signalReceived(false);
3918 AnimationFinishCheck finishCheck(signalReceived);
3919 animation.FinishedSignal().Connect(&application, finishCheck);
3921 application.SendNotification();
3922 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3924 // We didn't expect the animation to finish yet
3925 application.SendNotification();
3926 finishCheck.CheckSignalNotReceived();
3927 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3929 application.SendNotification();
3930 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3932 // We didn't expect the animation to finish yet
3933 application.SendNotification();
3934 finishCheck.CheckSignalNotReceived();
3935 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3937 application.SendNotification();
3938 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3940 // We did expect the animation to finish
3941 application.SendNotification();
3942 finishCheck.CheckSignalReceived();
3943 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3945 // Check that nothing has changed after a couple of buffer swaps
3946 application.Render(0);
3947 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3948 application.Render(0);
3949 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3953 int UtcDaliAnimationAnimateByVector3AlphaFunctionTimePeriodP(void)
3955 TestApplication application;
3957 Actor actor = Actor::New();
3959 // Register a Vector3 property
3960 Vector3 startValue(5.0f, 5.0f, 5.0f);
3961 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
3962 Stage::GetCurrent().Add(actor);
3963 DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
3964 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3966 // Build the animation
3967 float durationSeconds(1.0f);
3968 Animation animation = Animation::New(durationSeconds);
3969 Vector3 targetValue(10.0f, 10.0f, 10.0f);
3970 Vector3 relativeValue(targetValue - startValue);
3972 animation.AnimateBy(Property(actor, index),
3974 AlphaFunction::LINEAR,
3975 TimePeriod(delay, durationSeconds - delay));
3977 // Start the animation
3980 bool signalReceived(false);
3981 AnimationFinishCheck finishCheck(signalReceived);
3982 animation.FinishedSignal().Connect(&application, finishCheck);
3984 application.SendNotification();
3985 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3987 // We didn't expect the animation to finish yet
3988 application.SendNotification();
3989 finishCheck.CheckSignalNotReceived();
3990 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3992 application.SendNotification();
3993 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3995 // We didn't expect the animation to finish yet
3996 application.SendNotification();
3997 finishCheck.CheckSignalNotReceived();
3998 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
4000 application.SendNotification();
4001 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4003 // We did expect the animation to finish
4004 application.SendNotification();
4005 finishCheck.CheckSignalReceived();
4006 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
4008 // Check that nothing has changed after a couple of buffer swaps
4009 application.Render(0);
4010 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
4011 application.Render(0);
4012 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
4016 int UtcDaliAnimationAnimateByVector4P(void)
4018 TestApplication application;
4020 Actor actor = Actor::New();
4022 // Register a Vector4 property
4023 Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
4024 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
4025 Stage::GetCurrent().Add(actor);
4026 DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
4027 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4029 // Build the animation
4030 float durationSeconds(2.0f);
4031 Animation animation = Animation::New(durationSeconds);
4032 Vector4 targetValue(60.0f, 60.0f, 60.0f, 60.0f);
4033 Vector4 relativeValue(targetValue - startValue);
4034 animation.AnimateBy(Property(actor, index), relativeValue);
4036 Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
4038 // Start the animation
4041 bool signalReceived(false);
4042 AnimationFinishCheck finishCheck(signalReceived);
4043 animation.FinishedSignal().Connect(&application, finishCheck);
4045 application.SendNotification();
4046 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4048 // We didn't expect the animation to finish yet
4049 application.SendNotification();
4050 finishCheck.CheckSignalNotReceived();
4051 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
4053 application.SendNotification();
4054 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4056 // We did expect the animation to finish
4057 application.SendNotification();
4058 finishCheck.CheckSignalReceived();
4059 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4061 // Check that nothing has changed after a couple of buffer swaps
4062 application.Render(0);
4063 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4064 application.Render(0);
4065 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4069 int UtcDaliAnimationAnimateByVector4AlphaFunctionP(void)
4071 TestApplication application;
4073 Actor actor = Actor::New();
4075 // Register a Vector4 property
4076 Vector4 startValue(100.0f, 100.0f, 100.0f, 100.0f);
4077 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
4078 Stage::GetCurrent().Add(actor);
4079 DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
4080 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4082 // Build the animation
4083 float durationSeconds(1.0f);
4084 Animation animation = Animation::New(durationSeconds);
4085 Vector4 targetValue(20.0f, 20.0f, 20.0f, 20.0f);
4086 Vector4 relativeValue(targetValue - startValue);
4087 animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
4089 Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
4091 // Start the animation
4094 bool signalReceived(false);
4095 AnimationFinishCheck finishCheck(signalReceived);
4096 animation.FinishedSignal().Connect(&application, finishCheck);
4098 application.SendNotification();
4099 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4101 // We didn't expect the animation to finish yet
4102 application.SendNotification();
4103 finishCheck.CheckSignalNotReceived();
4105 // The position should have moved more, than with a linear alpha function
4106 Vector4 current( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ) );
4107 DALI_TEST_CHECK( current.x < ninetyFivePercentProgress.x );
4108 DALI_TEST_CHECK( current.y < ninetyFivePercentProgress.y );
4109 DALI_TEST_CHECK( current.z < ninetyFivePercentProgress.z );
4110 DALI_TEST_CHECK( current.w < ninetyFivePercentProgress.w );
4112 application.SendNotification();
4113 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4115 // We did expect the animation to finish
4116 application.SendNotification();
4117 finishCheck.CheckSignalReceived();
4118 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4120 // Check that nothing has changed after a couple of buffer swaps
4121 application.Render(0);
4122 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4123 application.Render(0);
4124 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4128 int UtcDaliAnimationAnimateByVector4TimePeriodP(void)
4130 TestApplication application;
4132 Actor actor = Actor::New();
4134 // Register a Vector4 property
4135 Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
4136 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
4137 Stage::GetCurrent().Add(actor);
4138 DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
4139 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4141 // Build the animation
4142 float durationSeconds(1.0f);
4143 Animation animation = Animation::New(durationSeconds);
4144 Vector4 targetValue(30.0f, 30.0f, 30.0f, 30.0f);
4145 Vector4 relativeValue(targetValue - startValue);
4147 animation.AnimateBy(Property(actor, index),
4149 TimePeriod(delay, durationSeconds - delay));
4151 // Start the animation
4154 bool signalReceived(false);
4155 AnimationFinishCheck finishCheck(signalReceived);
4156 animation.FinishedSignal().Connect(&application, finishCheck);
4158 application.SendNotification();
4159 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
4161 // We didn't expect the animation to finish yet
4162 application.SendNotification();
4163 finishCheck.CheckSignalNotReceived();
4164 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4166 application.SendNotification();
4167 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
4169 // We didn't expect the animation to finish yet
4170 application.SendNotification();
4171 finishCheck.CheckSignalNotReceived();
4172 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
4174 application.SendNotification();
4175 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4177 // We did expect the animation to finish
4178 application.SendNotification();
4179 finishCheck.CheckSignalReceived();
4180 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4182 // Check that nothing has changed after a couple of buffer swaps
4183 application.Render(0);
4184 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4185 application.Render(0);
4186 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4190 int UtcDaliAnimationAnimateByVector4AlphaFunctionTimePeriodP(void)
4192 TestApplication application;
4194 Actor actor = Actor::New();
4196 // Register a Vector4 property
4197 Vector4 startValue(5.0f, 5.0f, 5.0f, 5.0f);
4198 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
4199 Stage::GetCurrent().Add(actor);
4200 DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
4201 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4203 // Build the animation
4204 float durationSeconds(1.0f);
4205 Animation animation = Animation::New(durationSeconds);
4206 Vector4 targetValue(10.0f, 10.0f, 10.0f, 10.0f);
4207 Vector4 relativeValue(targetValue - startValue);
4209 animation.AnimateBy(Property(actor, index),
4211 AlphaFunction::LINEAR,
4212 TimePeriod(delay, durationSeconds - delay));
4214 // Start the animation
4217 bool signalReceived(false);
4218 AnimationFinishCheck finishCheck(signalReceived);
4219 animation.FinishedSignal().Connect(&application, finishCheck);
4221 application.SendNotification();
4222 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
4224 // We didn't expect the animation to finish yet
4225 application.SendNotification();
4226 finishCheck.CheckSignalNotReceived();
4227 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4229 application.SendNotification();
4230 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
4232 // We didn't expect the animation to finish yet
4233 application.SendNotification();
4234 finishCheck.CheckSignalNotReceived();
4235 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
4237 application.SendNotification();
4238 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4240 // We did expect the animation to finish
4241 application.SendNotification();
4242 finishCheck.CheckSignalReceived();
4243 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4245 // Check that nothing has changed after a couple of buffer swaps
4246 application.Render(0);
4247 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4248 application.Render(0);
4249 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4253 int UtcDaliAnimationAnimateByActorPositionP(void)
4255 TestApplication application;
4257 Actor actor = Actor::New();
4258 Vector3 startPosition(10.0f, 10.0f, 10.0f);
4259 actor.SetPosition(startPosition);
4260 Stage::GetCurrent().Add(actor);
4261 application.SendNotification();
4262 application.Render(0);
4263 DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4265 // Build the animation
4266 float durationSeconds(1.0f);
4267 Animation animation = Animation::New(durationSeconds);
4268 Vector3 targetPosition(20.0f, 20.0f, 20.0f);
4269 Vector3 relativePosition(targetPosition - startPosition);
4270 animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition);
4272 Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
4274 // Start the animation
4277 bool signalReceived(false);
4278 AnimationFinishCheck finishCheck(signalReceived);
4279 animation.FinishedSignal().Connect(&application, finishCheck);
4281 application.SendNotification();
4282 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4284 // We didn't expect the animation to finish yet
4285 application.SendNotification();
4286 finishCheck.CheckSignalNotReceived();
4287 DALI_TEST_EQUALS( actor.GetCurrentPosition(), ninetyFivePercentProgress, TEST_LOCATION );
4289 application.SendNotification();
4290 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4292 // We did expect the animation to finish
4293 application.SendNotification();
4294 finishCheck.CheckSignalReceived();
4295 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4297 // Check that nothing has changed after a couple of buffer swaps
4298 application.Render(0);
4299 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4300 application.Render(0);
4301 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4305 int UtcDaliAnimationAnimateByActorPositionAlphaFunctionP(void)
4307 TestApplication application;
4309 Actor actor = Actor::New();
4310 Vector3 startPosition(10.0f, 10.0f, 10.0f);
4311 actor.SetPosition(startPosition);
4312 Stage::GetCurrent().Add(actor);
4313 application.SendNotification();
4314 application.Render(0);
4315 DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4317 // Build the animation
4318 float durationSeconds(1.0f);
4319 Animation animation = Animation::New(durationSeconds);
4320 Vector3 targetPosition(20.0f, 20.0f, 20.0f);
4321 Vector3 relativePosition(targetPosition - startPosition);
4322 animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition, AlphaFunction::EASE_OUT);
4324 Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
4326 // Start the animation
4329 bool signalReceived(false);
4330 AnimationFinishCheck finishCheck(signalReceived);
4331 animation.FinishedSignal().Connect(&application, finishCheck);
4333 application.SendNotification();
4334 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4336 // We didn't expect the animation to finish yet
4337 application.SendNotification();
4338 finishCheck.CheckSignalNotReceived();
4340 // The position should have moved more, than with a linear alpha function
4341 Vector3 current(actor.GetCurrentPosition());
4342 DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
4343 DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
4344 DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
4346 application.SendNotification();
4347 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4349 // We did expect the animation to finish
4350 application.SendNotification();
4351 finishCheck.CheckSignalReceived();
4352 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4354 // Check that nothing has changed after a couple of buffer swaps
4355 application.Render(0);
4356 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4357 application.Render(0);
4358 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4362 int UtcDaliAnimationAnimateByActorPositionTimePeriodP(void)
4364 TestApplication application;
4366 Actor actor = Actor::New();
4367 Vector3 startPosition(10.0f, 10.0f, 10.0f);
4368 actor.SetPosition(startPosition);
4369 Stage::GetCurrent().Add(actor);
4370 application.SendNotification();
4371 application.Render(0);
4372 DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4374 // Build the animation
4375 float durationSeconds(1.0f);
4376 Animation animation = Animation::New(durationSeconds);
4377 Vector3 targetPosition(20.0f, 20.0f, 20.0f);
4378 Vector3 relativePosition(targetPosition - startPosition);
4380 animation.AnimateBy(Property(actor, Actor::Property::POSITION),
4382 TimePeriod(delay, durationSeconds - delay));
4384 Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
4386 // Start the animation
4389 bool signalReceived(false);
4390 AnimationFinishCheck finishCheck(signalReceived);
4391 animation.FinishedSignal().Connect(&application, finishCheck);
4393 application.SendNotification();
4394 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
4396 // We didn't expect the animation to finish yet
4397 application.SendNotification();
4398 finishCheck.CheckSignalNotReceived();
4399 DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4401 application.SendNotification();
4402 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
4404 // We did expect the animation to finish
4405 application.SendNotification();
4406 finishCheck.CheckSignalReceived();
4407 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4409 // Check that nothing has changed after a couple of buffer swaps
4410 application.Render(0);
4411 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4412 application.Render(0);
4413 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4417 int UtcDaliAnimationAnimateByActorPositionAlphaFunctionTimePeriodP(void)
4419 TestApplication application;
4421 Actor actor = Actor::New();
4422 Vector3 startPosition(10.0f, 10.0f, 10.0f);
4423 actor.SetPosition(startPosition);
4424 Stage::GetCurrent().Add(actor);
4425 application.SendNotification();
4426 application.Render(0);
4427 DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4429 // Build the animation
4430 float durationSeconds(1.0f);
4431 Animation animation = Animation::New(durationSeconds);
4432 Vector3 targetPosition(20.0f, 20.0f, 20.0f);
4433 Vector3 relativePosition(targetPosition - startPosition);
4435 animation.AnimateBy(Property(actor, Actor::Property::POSITION),
4437 AlphaFunction::LINEAR,
4438 TimePeriod(delay, durationSeconds - delay));
4440 Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
4442 // Start the animation
4445 bool signalReceived(false);
4446 AnimationFinishCheck finishCheck(signalReceived);
4447 animation.FinishedSignal().Connect(&application, finishCheck);
4449 application.SendNotification();
4450 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
4452 // We didn't expect the animation to finish yet
4453 application.SendNotification();
4454 finishCheck.CheckSignalNotReceived();
4455 DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4457 application.SendNotification();
4458 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
4460 // We did expect the animation to finish
4461 application.SendNotification();
4462 finishCheck.CheckSignalReceived();
4463 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4465 // Check that nothing has changed after a couple of buffer swaps
4466 application.Render(0);
4467 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4468 application.Render(0);
4469 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4473 int UtcDaliAnimationAnimateByActorOrientationP1(void)
4475 TestApplication application;
4477 Actor actor = Actor::New();
4478 actor.SetOrientation( Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
4479 Stage::GetCurrent().Add(actor);
4480 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
4482 // Build the animation
4483 float durationSeconds(1.0f);
4484 Animation animation = Animation::New(durationSeconds);
4485 Degree relativeRotationDegrees(360.0f);
4486 Radian relativeRotationRadians(relativeRotationDegrees);
4487 animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ) );
4489 // Start the animation
4492 bool signalReceived(false);
4493 AnimationFinishCheck finishCheck(signalReceived);
4494 animation.FinishedSignal().Connect(&application, finishCheck);
4496 application.SendNotification();
4497 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
4499 // We didn't expect the animation to finish yet
4500 application.SendNotification();
4501 finishCheck.CheckSignalNotReceived();
4502 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4504 application.SendNotification();
4505 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
4507 // We didn't expect the animation to finish yet
4508 application.SendNotification();
4509 finishCheck.CheckSignalNotReceived();
4510 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4512 application.SendNotification();
4513 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
4515 // We didn't expect the animation to finish yet
4516 application.SendNotification();
4517 finishCheck.CheckSignalNotReceived();
4518 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4520 application.SendNotification();
4521 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4523 // We did expect the animation to finish
4524 application.SendNotification();
4525 finishCheck.CheckSignalReceived();
4526 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4530 int UtcDaliAnimationAnimateByActorOrientationP2(void)
4532 TestApplication application;
4534 tet_printf("Testing that rotation angle > 360 performs full rotations\n");
4536 Actor actor = Actor::New();
4537 actor.SetOrientation( Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ) );
4538 Stage::GetCurrent().Add(actor);
4539 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ), ROTATION_EPSILON, TEST_LOCATION );
4541 // Build the animation
4542 float durationSeconds(1.0f);
4543 Animation animation = Animation::New(durationSeconds);
4544 Degree relativeRotationDegrees(710.0f);
4545 Radian relativeRotationRadians(relativeRotationDegrees);
4547 animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), AngleAxis( relativeRotationRadians, Vector3::ZAXIS ) );
4549 // Start the animation
4552 bool signalReceived(false);
4553 AnimationFinishCheck finishCheck(signalReceived);
4554 animation.FinishedSignal().Connect(&application, finishCheck);
4556 application.SendNotification();
4557 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
4559 // We didn't expect the animation to finish yet
4560 application.SendNotification();
4561 finishCheck.CheckSignalNotReceived();
4562 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.25f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4564 application.SendNotification();
4565 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
4567 // We didn't expect the animation to finish yet
4568 application.SendNotification();
4569 finishCheck.CheckSignalNotReceived();
4570 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.5f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4572 application.SendNotification();
4573 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
4575 // We didn't expect the animation to finish yet
4576 application.SendNotification();
4577 finishCheck.CheckSignalNotReceived();
4578 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.75f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4580 application.SendNotification();
4581 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4583 // We did expect the animation to finish
4584 application.SendNotification();
4585 finishCheck.CheckSignalReceived();
4586 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4591 int UtcDaliAnimationAnimateByActorOrientationP3(void)
4593 TestApplication application;
4595 tet_printf("Testing that rotation angle > 360 performs partial rotations when cast to Quaternion\n");
4597 Actor actor = Actor::New();
4598 actor.SetOrientation( Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ) );
4599 Stage::GetCurrent().Add(actor);
4600 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ), ROTATION_EPSILON, TEST_LOCATION );
4602 // Build the animation
4603 float durationSeconds(1.0f);
4604 Animation animation = Animation::New(durationSeconds);
4605 Degree relativeRotationDegrees(730.0f);
4606 Radian relativeRotationRadians(relativeRotationDegrees);
4608 Radian actualRotationRadians( Degree(10.0f) );
4610 animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::ZAXIS ) );
4612 // Start the animation
4615 bool signalReceived(false);
4616 AnimationFinishCheck finishCheck(signalReceived);
4617 animation.FinishedSignal().Connect(&application, finishCheck);
4619 application.SendNotification();
4620 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
4622 // We didn't expect the animation to finish yet
4623 application.SendNotification();
4624 finishCheck.CheckSignalNotReceived();
4625 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(actualRotationRadians * 0.25f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4627 application.SendNotification();
4628 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
4630 // We didn't expect the animation to finish yet
4631 application.SendNotification();
4632 finishCheck.CheckSignalNotReceived();
4633 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(actualRotationRadians * 0.5f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4635 application.SendNotification();
4636 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
4638 // We didn't expect the animation to finish yet
4639 application.SendNotification();
4640 finishCheck.CheckSignalNotReceived();
4641 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(actualRotationRadians * 0.75f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4643 application.SendNotification();
4644 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4646 // We did expect the animation to finish
4647 application.SendNotification();
4648 finishCheck.CheckSignalReceived();
4649 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(actualRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4650 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4655 int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionP(void)
4657 TestApplication application;
4659 Actor actor = Actor::New();
4660 actor.SetOrientation( Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
4661 Stage::GetCurrent().Add(actor);
4662 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
4664 // Build the animation
4665 float durationSeconds(1.0f);
4666 Animation animation = Animation::New(durationSeconds);
4667 Degree relativeRotationDegrees(360.0f);
4668 Radian relativeRotationRadians(relativeRotationDegrees);
4669 animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ), AlphaFunction::EASE_IN );
4671 // Start the animation
4674 bool signalReceived(false);
4675 AnimationFinishCheck finishCheck(signalReceived);
4676 animation.FinishedSignal().Connect(&application, finishCheck);
4678 application.SendNotification();
4679 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
4681 // We didn't expect the animation to finish yet
4682 application.SendNotification();
4683 finishCheck.CheckSignalNotReceived();
4684 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.25f*0.25f*0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4686 application.SendNotification();
4687 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
4689 // We didn't expect the animation to finish yet
4690 application.SendNotification();
4691 finishCheck.CheckSignalNotReceived();
4692 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.5f*0.5f*0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4694 application.SendNotification();
4695 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
4697 // We didn't expect the animation to finish yet
4698 application.SendNotification();
4699 finishCheck.CheckSignalNotReceived();
4700 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.75f*0.75f*0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4702 application.SendNotification();
4703 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4705 // We did expect the animation to finish
4706 application.SendNotification();
4707 finishCheck.CheckSignalReceived();
4708 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4712 int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionTimePeriodP(void)
4714 TestApplication application;
4716 Actor actor = Actor::New();
4717 actor.SetOrientation( Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
4718 Stage::GetCurrent().Add(actor);
4719 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
4721 // Build the animation
4722 float durationSeconds(1.0f);
4723 Animation animation = Animation::New(durationSeconds);
4724 Degree relativeRotationDegrees(360.0f);
4725 Radian relativeRotationRadians(relativeRotationDegrees);
4727 animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ),
4728 AlphaFunction::EASE_IN, TimePeriod( delay, durationSeconds - delay ) );
4730 // Start the animation
4733 bool signalReceived(false);
4734 AnimationFinishCheck finishCheck(signalReceived);
4735 animation.FinishedSignal().Connect(&application, finishCheck);
4737 application.SendNotification();
4738 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
4740 // We didn't expect the animation to finish yet
4741 application.SendNotification();
4742 finishCheck.CheckSignalNotReceived();
4743 float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
4744 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4746 application.SendNotification();
4747 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
4749 // We didn't expect the animation to finish yet
4750 application.SendNotification();
4751 finishCheck.CheckSignalNotReceived();
4752 progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
4753 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4755 application.SendNotification();
4756 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
4758 // We didn't expect the animation to finish yet
4759 application.SendNotification();
4760 finishCheck.CheckSignalNotReceived();
4761 progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
4762 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4764 application.SendNotification();
4765 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4767 // We did expect the animation to finish
4768 application.SendNotification();
4769 finishCheck.CheckSignalReceived();
4770 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4774 int UtcDaliAnimationAnimateByActorScaleP(void)
4776 TestApplication application;
4778 Actor actor = Actor::New();
4779 Stage::GetCurrent().Add(actor);
4780 DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
4782 // Build the animation
4783 float durationSeconds(1.0f);
4784 Animation animation = Animation::New(durationSeconds);
4785 Vector3 targetScale(2.0f, 2.0f, 2.0f);
4786 Vector3 relativeScale(targetScale - Vector3::ONE);
4787 animation.AnimateBy( Property( actor, Actor::Property::SCALE ), Vector3( relativeScale.x, relativeScale.y, relativeScale.z ) );
4789 Vector3 ninetyNinePercentProgress(Vector3::ONE + relativeScale*0.99f);
4791 // Start the animation
4794 bool signalReceived(false);
4795 AnimationFinishCheck finishCheck(signalReceived);
4796 animation.FinishedSignal().Connect(&application, finishCheck);
4798 application.SendNotification();
4799 application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
4801 // We didn't expect the animation to finish yet
4802 application.SendNotification();
4803 finishCheck.CheckSignalNotReceived();
4804 DALI_TEST_EQUALS( actor.GetCurrentScale(), ninetyNinePercentProgress, TEST_LOCATION );
4806 application.SendNotification();
4807 application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
4809 // We did expect the animation to finish
4810 application.SendNotification();
4811 finishCheck.CheckSignalReceived();
4812 DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
4815 finishCheck.Reset();
4816 actor.SetScale(Vector3::ONE);
4817 application.SendNotification();
4818 application.Render(0);
4819 DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
4821 // Repeat with a different (ease-in) alpha function
4822 animation = Animation::New(durationSeconds);
4823 animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunction::EASE_IN );
4824 animation.FinishedSignal().Connect(&application, finishCheck);
4827 application.SendNotification();
4828 application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
4830 // We didn't expect the animation to finish yet
4831 application.SendNotification();
4832 finishCheck.CheckSignalNotReceived();
4834 // The scale should have grown less, than with a linear alpha function
4835 Vector3 current(actor.GetCurrentScale());
4836 DALI_TEST_CHECK( current.x > 1.0f );
4837 DALI_TEST_CHECK( current.y > 1.0f );
4838 DALI_TEST_CHECK( current.z > 1.0f );
4839 DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
4840 DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
4841 DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
4843 application.SendNotification();
4844 application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
4846 // We did expect the animation to finish
4847 application.SendNotification();
4848 finishCheck.CheckSignalReceived();
4849 DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
4852 finishCheck.Reset();
4853 actor.SetScale(Vector3::ONE);
4854 application.SendNotification();
4855 application.Render(0);
4856 DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
4858 // Repeat with a delay
4860 animation = Animation::New(durationSeconds);
4861 animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
4862 animation.FinishedSignal().Connect(&application, finishCheck);
4865 application.SendNotification();
4866 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
4868 // We didn't expect the animation to finish yet
4869 application.SendNotification();
4870 finishCheck.CheckSignalNotReceived();
4871 DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
4873 application.SendNotification();
4874 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
4876 // We did expect the animation to finish
4877 application.SendNotification();
4878 finishCheck.CheckSignalReceived();
4879 DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
4883 int UtcDaliAnimationAnimateToBooleanP(void)
4885 TestApplication application;
4887 Actor actor = Actor::New();
4889 // Register a boolean property
4890 const bool startValue(false);
4891 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
4892 Stage::GetCurrent().Add(actor);
4893 DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
4894 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
4896 // Build the animation
4897 float durationSeconds(2.0f);
4898 Animation animation = Animation::New(durationSeconds);
4899 const bool targetValue( !startValue );
4900 animation.AnimateTo(Property(actor, index), targetValue);
4902 // Start the animation
4905 bool signalReceived(false);
4906 AnimationFinishCheck finishCheck(signalReceived);
4907 animation.FinishedSignal().Connect(&application, finishCheck);
4909 application.SendNotification();
4910 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4912 // We didn't expect the animation to finish yet
4913 application.SendNotification();
4914 finishCheck.CheckSignalNotReceived();
4915 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
4917 application.SendNotification();
4918 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4920 // We did expect the animation to finish
4921 application.SendNotification();
4922 finishCheck.CheckSignalReceived();
4923 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
4925 // Check that nothing has changed after a couple of buffer swaps
4926 application.Render(0);
4927 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
4928 application.Render(0);
4929 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
4931 // Repeat with target value "false"
4932 animation = Animation::New(durationSeconds);
4933 const bool finalValue( !targetValue );
4934 animation.AnimateTo(Property(actor, index), finalValue);
4936 // Start the animation
4939 finishCheck.Reset();
4940 animation.FinishedSignal().Connect(&application, finishCheck);
4942 application.SendNotification();
4943 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4945 // We didn't expect the animation to finish yet
4946 application.SendNotification();
4947 finishCheck.CheckSignalNotReceived();
4948 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
4950 application.SendNotification();
4951 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4953 // We did expect the animation to finish
4954 application.SendNotification();
4955 finishCheck.CheckSignalReceived();
4956 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
4958 // Check that nothing has changed after a couple of buffer swaps
4959 application.Render(0);
4960 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
4961 application.Render(0);
4962 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
4966 int UtcDaliAnimationAnimateToBooleanAlphaFunctionP(void)
4968 TestApplication application;
4970 Actor actor = Actor::New();
4972 // Register a boolean property
4973 const bool startValue(false);
4974 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
4975 Stage::GetCurrent().Add(actor);
4976 DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
4977 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
4979 // Build the animation
4980 float durationSeconds(2.0f);
4981 Animation animation = Animation::New(durationSeconds);
4982 const bool targetValue( !startValue );
4983 animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction::EASE_OUT);
4985 // Start the animation
4988 bool signalReceived(false);
4989 AnimationFinishCheck finishCheck(signalReceived);
4990 animation.FinishedSignal().Connect(&application, finishCheck);
4992 application.SendNotification();
4993 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4995 // We didn't expect the animation to finish yet
4996 application.SendNotification();
4997 finishCheck.CheckSignalNotReceived();
4998 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
5000 application.SendNotification();
5001 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5003 // We did expect the animation to finish
5004 application.SendNotification();
5005 finishCheck.CheckSignalReceived();
5006 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
5008 // Check that nothing has changed after a couple of buffer swaps
5009 application.Render(0);
5010 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
5011 application.Render(0);
5012 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
5014 // Repeat with target value "false"
5015 animation = Animation::New(durationSeconds);
5016 const bool finalValue( !targetValue );
5017 animation.AnimateTo(Property(actor, index), finalValue, AlphaFunction::EASE_OUT);
5019 // Start the animation
5022 finishCheck.Reset();
5023 animation.FinishedSignal().Connect(&application, finishCheck);
5025 application.SendNotification();
5026 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5028 // We didn't expect the animation to finish yet
5029 application.SendNotification();
5030 finishCheck.CheckSignalNotReceived();
5031 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
5033 application.SendNotification();
5034 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5036 // We did expect the animation to finish
5037 application.SendNotification();
5038 finishCheck.CheckSignalReceived();
5039 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5041 // Check that nothing has changed after a couple of buffer swaps
5042 application.Render(0);
5043 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5044 application.Render(0);
5045 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5049 int UtcDaliAnimationAnimateToBooleanTimePeriodP(void)
5051 TestApplication application;
5053 Actor actor = Actor::New();
5055 // Register a boolean property
5056 bool startValue(false);
5057 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5058 Stage::GetCurrent().Add(actor);
5059 DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
5060 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
5062 // Build the animation
5063 float durationSeconds(2.0f);
5064 Animation animation = Animation::New(durationSeconds);
5065 bool finalValue( !startValue );
5066 float animatorDurationSeconds(durationSeconds * 0.5f);
5067 animation.AnimateTo( Property(actor, index),
5069 TimePeriod( animatorDurationSeconds ) );
5071 // Start the animation
5074 bool signalReceived(false);
5075 AnimationFinishCheck finishCheck(signalReceived);
5076 animation.FinishedSignal().Connect(&application, finishCheck);
5078 application.SendNotification();
5079 application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
5081 // We didn't expect the animation to finish yet
5082 application.SendNotification();
5083 finishCheck.CheckSignalNotReceived();
5084 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
5086 application.SendNotification();
5087 application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
5089 // We didn't expect the animation to finish yet...
5090 application.SendNotification();
5091 finishCheck.CheckSignalNotReceived();
5093 // ...however we should have reached the final value
5094 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5096 application.SendNotification();
5097 application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
5099 // We did expect the animation to finish
5100 application.SendNotification();
5101 finishCheck.CheckSignalReceived();
5102 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5104 // Check that nothing has changed after a couple of buffer swaps
5105 application.Render(0);
5106 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5107 application.Render(0);
5108 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5112 int UtcDaliAnimationAnimateToBooleanAlphaFunctionTimePeriodP(void)
5114 TestApplication application;
5116 Actor actor = Actor::New();
5118 // Register a boolean property
5119 bool startValue(false);
5120 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5121 Stage::GetCurrent().Add(actor);
5122 DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
5123 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
5125 // Build the animation
5126 float durationSeconds(2.0f);
5127 Animation animation = Animation::New(durationSeconds);
5128 bool finalValue( !startValue );
5129 float animatorDurationSeconds(durationSeconds * 0.5f);
5130 animation.AnimateTo( Property(actor, index),
5132 AlphaFunction::LINEAR,
5133 TimePeriod( animatorDurationSeconds ) );
5135 // Start the animation
5138 bool signalReceived(false);
5139 AnimationFinishCheck finishCheck(signalReceived);
5140 animation.FinishedSignal().Connect(&application, finishCheck);
5142 application.SendNotification();
5143 application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
5145 // We didn't expect the animation to finish yet
5146 application.SendNotification();
5147 finishCheck.CheckSignalNotReceived();
5148 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
5150 application.SendNotification();
5151 application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
5153 // We didn't expect the animation to finish yet...
5154 application.SendNotification();
5155 finishCheck.CheckSignalNotReceived();
5157 // ...however we should have reached the final value
5158 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5160 application.SendNotification();
5161 application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
5163 // We did expect the animation to finish
5164 application.SendNotification();
5165 finishCheck.CheckSignalReceived();
5166 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5168 // Check that nothing has changed after a couple of buffer swaps
5169 application.Render(0);
5170 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5171 application.Render(0);
5172 DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5176 int UtcDaliAnimationAnimateToFloatP(void)
5178 TestApplication application;
5180 Actor actor = Actor::New();
5182 // Register a float property
5183 float startValue(10.0f);
5184 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5185 Stage::GetCurrent().Add(actor);
5186 DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
5187 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5189 // Build the animation
5190 float durationSeconds(2.0f);
5191 Animation animation = Animation::New(durationSeconds);
5192 float targetValue(50.0f);
5193 float relativeValue(targetValue - startValue);
5194 animation.AnimateTo(Property(actor, "testProperty"), targetValue);
5196 float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5198 // Start the animation
5201 bool signalReceived(false);
5202 AnimationFinishCheck finishCheck(signalReceived);
5203 animation.FinishedSignal().Connect(&application, finishCheck);
5205 application.SendNotification();
5206 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5208 // We didn't expect the animation to finish yet
5209 application.SendNotification();
5210 finishCheck.CheckSignalNotReceived();
5211 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
5213 application.SendNotification();
5214 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5216 // We did expect the animation to finish
5217 application.SendNotification();
5218 finishCheck.CheckSignalReceived();
5219 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
5223 int UtcDaliAnimationAnimateToFloatAlphaFunctionP(void)
5225 TestApplication application;
5227 Actor actor = Actor::New();
5229 // Register a float property
5230 float startValue(10.0f);
5231 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5232 Stage::GetCurrent().Add(actor);
5233 DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
5234 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5236 // Build the animation
5237 float durationSeconds(1.0f);
5238 Animation animation = Animation::New(durationSeconds);
5239 float targetValue(90.0f);
5240 float relativeValue(targetValue - startValue);
5241 animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
5243 float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5245 // Start the animation
5248 bool signalReceived(false);
5249 AnimationFinishCheck finishCheck(signalReceived);
5250 animation.FinishedSignal().Connect(&application, finishCheck);
5252 application.SendNotification();
5253 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5255 // We didn't expect the animation to finish yet
5256 application.SendNotification();
5257 finishCheck.CheckSignalNotReceived();
5259 // The position should have moved more, than with a linear alpha function
5260 float current( DevelHandle::GetCurrentProperty< float >( actor, index ) );
5261 DALI_TEST_CHECK( current > ninetyFivePercentProgress );
5263 application.SendNotification();
5264 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5266 // We did expect the animation to finish
5267 application.SendNotification();
5268 finishCheck.CheckSignalReceived();
5269 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
5273 int UtcDaliAnimationAnimateToFloatTimePeriodP(void)
5275 TestApplication application;
5277 Actor actor = Actor::New();
5279 // Register a float property
5280 float startValue(10.0f);
5281 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5282 Stage::GetCurrent().Add(actor);
5283 DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
5284 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5286 // Build the animation
5287 float durationSeconds(1.0f);
5288 Animation animation = Animation::New(durationSeconds);
5289 float targetValue(30.0f);
5290 float relativeValue(targetValue - startValue);
5292 animation.AnimateTo(Property(actor, index),
5294 TimePeriod(delay, durationSeconds - delay));
5296 // Start the animation
5299 bool signalReceived(false);
5300 AnimationFinishCheck finishCheck(signalReceived);
5301 animation.FinishedSignal().Connect(&application, finishCheck);
5303 application.SendNotification();
5304 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5306 // We didn't expect the animation to finish yet
5307 application.SendNotification();
5308 finishCheck.CheckSignalNotReceived();
5309 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5311 application.SendNotification();
5312 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5314 // We didn't expect the animation to finish yet
5315 application.SendNotification();
5316 finishCheck.CheckSignalNotReceived();
5317 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
5319 application.SendNotification();
5320 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5322 // We did expect the animation to finish
5323 application.SendNotification();
5324 finishCheck.CheckSignalReceived();
5325 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
5329 int UtcDaliAnimationAnimateToFloatAlphaFunctionTimePeriodP(void)
5331 TestApplication application;
5333 Actor actor = Actor::New();
5335 // Register a float property
5336 float startValue(10.0f);
5337 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5338 Stage::GetCurrent().Add(actor);
5339 DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
5340 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5342 // Build the animation
5343 float durationSeconds(1.0f);
5344 Animation animation = Animation::New(durationSeconds);
5345 float targetValue(30.0f);
5346 float relativeValue(targetValue - startValue);
5348 animation.AnimateTo(Property(actor, index),
5350 AlphaFunction::LINEAR,
5351 TimePeriod(delay, durationSeconds - delay));
5353 // Start the animation
5356 bool signalReceived(false);
5357 AnimationFinishCheck finishCheck(signalReceived);
5358 animation.FinishedSignal().Connect(&application, finishCheck);
5360 application.SendNotification();
5361 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5363 // We didn't expect the animation to finish yet
5364 application.SendNotification();
5365 finishCheck.CheckSignalNotReceived();
5366 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5368 application.SendNotification();
5369 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5371 // We didn't expect the animation to finish yet
5372 application.SendNotification();
5373 finishCheck.CheckSignalNotReceived();
5374 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
5376 application.SendNotification();
5377 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5379 // We did expect the animation to finish
5380 application.SendNotification();
5381 finishCheck.CheckSignalReceived();
5382 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
5386 int UtcDaliAnimationAnimateToIntegerP(void)
5388 TestApplication application;
5390 Actor actor = Actor::New();
5392 // Register an integer property
5394 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5395 Stage::GetCurrent().Add(actor);
5396 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
5397 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5399 // Build the animation
5400 float durationSeconds(2.0f);
5401 Animation animation = Animation::New(durationSeconds);
5402 int targetValue(50);
5403 int relativeValue(targetValue - startValue);
5404 animation.AnimateTo(Property(actor, "testProperty"), targetValue);
5406 int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
5408 // Start the animation
5411 bool signalReceived(false);
5412 AnimationFinishCheck finishCheck(signalReceived);
5413 animation.FinishedSignal().Connect(&application, finishCheck);
5415 application.SendNotification();
5416 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5418 // We didn't expect the animation to finish yet
5419 application.SendNotification();
5420 finishCheck.CheckSignalNotReceived();
5421 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
5423 application.SendNotification();
5424 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5426 // We did expect the animation to finish
5427 application.SendNotification();
5428 finishCheck.CheckSignalReceived();
5429 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
5433 int UtcDaliAnimationAnimateToIntegerAlphaFunctionP(void)
5435 TestApplication application;
5437 Actor actor = Actor::New();
5439 // Register an integer property
5441 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5442 Stage::GetCurrent().Add(actor);
5443 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
5444 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5446 // Build the animation
5447 float durationSeconds(1.0f);
5448 Animation animation = Animation::New(durationSeconds);
5449 int targetValue(90);
5450 int relativeValue(targetValue - startValue);
5451 animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
5453 int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
5455 // Start the animation
5458 bool signalReceived(false);
5459 AnimationFinishCheck finishCheck(signalReceived);
5460 animation.FinishedSignal().Connect(&application, finishCheck);
5462 application.SendNotification();
5463 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5465 // We didn't expect the animation to finish yet
5466 application.SendNotification();
5467 finishCheck.CheckSignalNotReceived();
5469 // The position should have moved more, than with a linear alpha function
5470 int current( DevelHandle::GetCurrentProperty< int >( actor, index ) );
5471 DALI_TEST_CHECK( current > ninetyFivePercentProgress );
5473 application.SendNotification();
5474 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5476 // We did expect the animation to finish
5477 application.SendNotification();
5478 finishCheck.CheckSignalReceived();
5479 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
5483 int UtcDaliAnimationAnimateToIntegerTimePeriodP(void)
5485 TestApplication application;
5487 Actor actor = Actor::New();
5489 // Register an integer property
5491 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5492 Stage::GetCurrent().Add(actor);
5493 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
5494 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5496 // Build the animation
5497 float durationSeconds(1.0f);
5498 Animation animation = Animation::New(durationSeconds);
5499 int targetValue(30);
5500 int relativeValue(targetValue - startValue);
5502 animation.AnimateTo(Property(actor, index),
5504 TimePeriod(delay, durationSeconds - delay));
5506 // Start the animation
5509 bool signalReceived(false);
5510 AnimationFinishCheck finishCheck(signalReceived);
5511 animation.FinishedSignal().Connect(&application, finishCheck);
5513 application.SendNotification();
5514 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5516 // We didn't expect the animation to finish yet
5517 application.SendNotification();
5518 finishCheck.CheckSignalNotReceived();
5519 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5521 application.SendNotification();
5522 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5524 // We didn't expect the animation to finish yet
5525 application.SendNotification();
5526 finishCheck.CheckSignalNotReceived();
5527 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
5529 application.SendNotification();
5530 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5532 // We did expect the animation to finish
5533 application.SendNotification();
5534 finishCheck.CheckSignalReceived();
5535 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
5539 int UtcDaliAnimationAnimateToIntegerAlphaFunctionTimePeriodP(void)
5541 TestApplication application;
5543 Actor actor = Actor::New();
5545 // Register an integer property
5547 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5548 Stage::GetCurrent().Add(actor);
5549 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
5550 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5552 // Build the animation
5553 float durationSeconds(1.0f);
5554 Animation animation = Animation::New(durationSeconds);
5555 int targetValue(30);
5556 int relativeValue(targetValue - startValue);
5558 animation.AnimateTo(Property(actor, index),
5560 AlphaFunction::LINEAR,
5561 TimePeriod(delay, durationSeconds - delay));
5563 // Start the animation
5566 bool signalReceived(false);
5567 AnimationFinishCheck finishCheck(signalReceived);
5568 animation.FinishedSignal().Connect(&application, finishCheck);
5570 application.SendNotification();
5571 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5573 // We didn't expect the animation to finish yet
5574 application.SendNotification();
5575 finishCheck.CheckSignalNotReceived();
5576 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5578 application.SendNotification();
5579 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5581 // We didn't expect the animation to finish yet
5582 application.SendNotification();
5583 finishCheck.CheckSignalNotReceived();
5584 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
5586 application.SendNotification();
5587 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5589 // We did expect the animation to finish
5590 application.SendNotification();
5591 finishCheck.CheckSignalReceived();
5592 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
5596 int UtcDaliAnimationAnimateToVector2P(void)
5598 TestApplication application;
5600 Actor actor = Actor::New();
5602 // Register a Vector2 property
5603 Vector2 startValue(-50.0f, -50.0f);
5604 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5605 Stage::GetCurrent().Add(actor);
5606 DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
5607 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
5609 // Build the animation
5610 float durationSeconds(2.0f);
5611 Animation animation = Animation::New(durationSeconds);
5612 Vector2 targetValue(50.0f, 50.0f);
5613 Vector2 relativeValue(targetValue - startValue);
5614 animation.AnimateTo(Property(actor, index), targetValue);
5616 Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5618 // Start the animation
5621 bool signalReceived(false);
5622 AnimationFinishCheck finishCheck(signalReceived);
5623 animation.FinishedSignal().Connect(&application, finishCheck);
5625 application.SendNotification();
5626 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5628 // We didn't expect the animation to finish yet
5629 application.SendNotification();
5630 finishCheck.CheckSignalNotReceived();
5631 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
5633 application.SendNotification();
5634 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5636 // We did expect the animation to finish
5637 application.SendNotification();
5638 finishCheck.CheckSignalReceived();
5639 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
5643 int UtcDaliAnimationAnimateToVector2AlphaFunctionP(void)
5645 TestApplication application;
5647 Actor actor = Actor::New();
5649 // Register a Vector2 property
5650 Vector2 startValue(1000.0f, 1000.0f);
5651 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5652 Stage::GetCurrent().Add(actor);
5653 DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
5654 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
5656 // Build the animation
5657 float durationSeconds(1.0f);
5658 Animation animation = Animation::New(durationSeconds);
5659 Vector2 targetValue(9000.0f, 9000.0f);
5660 Vector2 relativeValue(targetValue - startValue);
5661 animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction::EASE_OUT);
5663 Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5665 // Start the animation
5668 bool signalReceived(false);
5669 AnimationFinishCheck finishCheck(signalReceived);
5670 animation.FinishedSignal().Connect(&application, finishCheck);
5672 application.SendNotification();
5673 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5675 // We didn't expect the animation to finish yet
5676 application.SendNotification();
5677 finishCheck.CheckSignalNotReceived();
5679 // The position should have moved more, than with a linear alpha function
5680 Vector2 current( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ) );
5681 DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
5682 DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
5684 application.SendNotification();
5685 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5687 // We did expect the animation to finish
5688 application.SendNotification();
5689 finishCheck.CheckSignalReceived();
5690 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
5694 int UtcDaliAnimationAnimateToVector2TimePeriodP(void)
5696 TestApplication application;
5698 Actor actor = Actor::New();
5700 // Register a Vector2 property
5701 Vector2 startValue(10.0f, 10.0f);
5702 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5703 Stage::GetCurrent().Add(actor);
5704 DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
5705 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
5707 // Build the animation
5708 float durationSeconds(1.0f);
5709 Animation animation = Animation::New(durationSeconds);
5710 Vector2 targetValue(-10.0f, 20.0f);
5711 Vector2 relativeValue(targetValue - startValue);
5713 animation.AnimateTo(Property(actor, index),
5715 TimePeriod(delay, durationSeconds - delay));
5717 // Start the animation
5720 bool signalReceived(false);
5721 AnimationFinishCheck finishCheck(signalReceived);
5722 animation.FinishedSignal().Connect(&application, finishCheck);
5724 application.SendNotification();
5725 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5727 // We didn't expect the animation to finish yet
5728 application.SendNotification();
5729 finishCheck.CheckSignalNotReceived();
5730 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
5732 application.SendNotification();
5733 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5735 // We didn't expect the animation to finish yet
5736 application.SendNotification();
5737 finishCheck.CheckSignalNotReceived();
5738 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
5740 application.SendNotification();
5741 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5743 // We did expect the animation to finish
5744 application.SendNotification();
5745 finishCheck.CheckSignalReceived();
5746 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
5750 int UtcDaliAnimationAnimateToVector2AlphaFunctionTimePeriodP(void)
5752 TestApplication application;
5754 Actor actor = Actor::New();
5756 // Register a Vector2 property
5757 Vector2 startValue(10.0f, 10.0f);
5758 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5759 Stage::GetCurrent().Add(actor);
5760 DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
5761 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
5763 // Build the animation
5764 float durationSeconds(1.0f);
5765 Animation animation = Animation::New(durationSeconds);
5766 Vector2 targetValue(30.0f, 30.0f);
5767 Vector2 relativeValue(targetValue - startValue);
5769 animation.AnimateTo(Property(actor, index),
5771 AlphaFunction::LINEAR,
5772 TimePeriod(delay, durationSeconds - delay));
5774 // Start the animation
5777 bool signalReceived(false);
5778 AnimationFinishCheck finishCheck(signalReceived);
5779 animation.FinishedSignal().Connect(&application, finishCheck);
5781 application.SendNotification();
5782 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5784 // We didn't expect the animation to finish yet
5785 application.SendNotification();
5786 finishCheck.CheckSignalNotReceived();
5787 DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
5789 application.SendNotification();
5790 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5792 // We didn't expect the animation to finish yet
5793 application.SendNotification();
5794 finishCheck.CheckSignalNotReceived();
5795 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
5797 application.SendNotification();
5798 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5800 // We did expect the animation to finish
5801 application.SendNotification();
5802 finishCheck.CheckSignalReceived();
5803 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
5807 int UtcDaliAnimationAnimateToVector3P(void)
5809 TestApplication application;
5811 Actor actor = Actor::New();
5813 // Register a Vector3 property
5814 Vector3 startValue(-50.0f, -50.0f, -50.0f);
5815 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5816 Stage::GetCurrent().Add(actor);
5817 DALI_TEST_EQUALS( actor.GetProperty<Vector3>( index ), startValue, TEST_LOCATION );
5818 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
5820 // Build the animation
5821 float durationSeconds(2.0f);
5822 Animation animation = Animation::New(durationSeconds);
5823 Vector3 targetValue(50.0f, 50.0f, 50.0f);
5824 Vector3 relativeValue(targetValue - startValue);
5825 animation.AnimateTo(Property(actor, index), targetValue);
5827 Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5829 // Start the animation
5832 bool signalReceived(false);
5833 AnimationFinishCheck finishCheck(signalReceived);
5834 animation.FinishedSignal().Connect(&application, finishCheck);
5836 application.SendNotification();
5837 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5839 // We didn't expect the animation to finish yet
5840 application.SendNotification();
5841 finishCheck.CheckSignalNotReceived();
5842 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
5844 application.SendNotification();
5845 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5847 // We did expect the animation to finish
5848 application.SendNotification();
5849 finishCheck.CheckSignalReceived();
5850 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
5854 int UtcDaliAnimationAnimateToVector3AlphaFunctionP(void)
5856 TestApplication application;
5858 Actor actor = Actor::New();
5860 // Register a Vector3 property
5861 Vector3 startValue(1000.0f, 1000.0f, 1000.0f);
5862 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5863 Stage::GetCurrent().Add(actor);
5864 DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
5865 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
5867 // Build the animation
5868 float durationSeconds(1.0f);
5869 Animation animation = Animation::New(durationSeconds);
5870 Vector3 targetValue(9000.0f, 9000.0f, 9000.0f);
5871 Vector3 relativeValue(targetValue - startValue);
5872 animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
5874 Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5876 // Start the animation
5879 bool signalReceived(false);
5880 AnimationFinishCheck finishCheck(signalReceived);
5881 animation.FinishedSignal().Connect(&application, finishCheck);
5883 application.SendNotification();
5884 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5886 // We didn't expect the animation to finish yet
5887 application.SendNotification();
5888 finishCheck.CheckSignalNotReceived();
5890 // The position should have moved more, than with a linear alpha function
5891 Vector3 current( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ) );
5892 DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
5893 DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
5894 DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
5896 application.SendNotification();
5897 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5899 // We did expect the animation to finish
5900 application.SendNotification();
5901 finishCheck.CheckSignalReceived();
5902 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
5906 int UtcDaliAnimationAnimateToVector3TimePeriodP(void)
5908 TestApplication application;
5910 Actor actor = Actor::New();
5912 // Register a Vector3 property
5913 Vector3 startValue(10.0f, 10.0f, 10.0f);
5914 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5915 Stage::GetCurrent().Add(actor);
5916 DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
5917 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
5919 // Build the animation
5920 float durationSeconds(1.0f);
5921 Animation animation = Animation::New(durationSeconds);
5922 Vector3 targetValue(-10.0f, 20.0f, 100.0f);
5923 Vector3 relativeValue(targetValue - startValue);
5925 animation.AnimateTo(Property(actor, index),
5927 TimePeriod(delay, durationSeconds - delay));
5929 // Start the animation
5932 bool signalReceived(false);
5933 AnimationFinishCheck finishCheck(signalReceived);
5934 animation.FinishedSignal().Connect(&application, finishCheck);
5936 application.SendNotification();
5937 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5939 // We didn't expect the animation to finish yet
5940 application.SendNotification();
5941 finishCheck.CheckSignalNotReceived();
5942 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
5944 application.SendNotification();
5945 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5947 // We didn't expect the animation to finish yet
5948 application.SendNotification();
5949 finishCheck.CheckSignalNotReceived();
5950 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
5952 application.SendNotification();
5953 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5955 // We did expect the animation to finish
5956 application.SendNotification();
5957 finishCheck.CheckSignalReceived();
5958 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
5962 int UtcDaliAnimationAnimateToVector3AlphaFunctionTimePeriodP(void)
5964 TestApplication application;
5966 Actor actor = Actor::New();
5968 // Register a Vector3 property
5969 Vector3 startValue(10.0f, 10.0f, 10.0f);
5970 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
5971 Stage::GetCurrent().Add(actor);
5972 DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
5973 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
5975 // Build the animation
5976 float durationSeconds(1.0f);
5977 Animation animation = Animation::New(durationSeconds);
5978 Vector3 targetValue(30.0f, 30.0f, 30.0f);
5979 Vector3 relativeValue(targetValue - startValue);
5981 animation.AnimateTo(Property(actor, "testProperty"),
5983 AlphaFunction::LINEAR,
5984 TimePeriod(delay, durationSeconds - delay));
5986 // Start the animation
5989 bool signalReceived(false);
5990 AnimationFinishCheck finishCheck(signalReceived);
5991 animation.FinishedSignal().Connect(&application, finishCheck);
5993 application.SendNotification();
5994 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5996 // We didn't expect the animation to finish yet
5997 application.SendNotification();
5998 finishCheck.CheckSignalNotReceived();
5999 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
6001 application.SendNotification();
6002 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
6004 // We didn't expect the animation to finish yet
6005 application.SendNotification();
6006 finishCheck.CheckSignalNotReceived();
6007 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
6009 application.SendNotification();
6010 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
6012 // We did expect the animation to finish
6013 application.SendNotification();
6014 finishCheck.CheckSignalReceived();
6015 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
6019 int UtcDaliAnimationAnimateToVector3ComponentP(void)
6021 TestApplication application;
6023 Actor actor = Actor::New();
6025 // Register a Vector3 property
6026 Vector3 startValue(10.0f, 10.0f, 10.0f);
6027 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
6028 Stage::GetCurrent().Add(actor);
6029 DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
6030 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
6032 // Build the animation
6033 float durationSeconds(1.0f);
6034 Animation animation = Animation::New(durationSeconds);
6035 Vector3 targetValue(30.0f, 30.0f, 10.0f);
6036 Vector3 relativeValue(targetValue - startValue);
6038 animation.AnimateTo(Property(actor, "testProperty", 0),
6040 AlphaFunction::LINEAR,
6041 TimePeriod(delay, durationSeconds - delay));
6042 animation.AnimateTo(Property(actor, index, 1),
6044 AlphaFunction::LINEAR,
6045 TimePeriod(delay, durationSeconds - delay));
6047 // Start the animation
6050 bool signalReceived(false);
6051 AnimationFinishCheck finishCheck(signalReceived);
6052 animation.FinishedSignal().Connect(&application, finishCheck);
6054 application.SendNotification();
6055 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
6057 // We didn't expect the animation to finish yet
6058 application.SendNotification();
6059 finishCheck.CheckSignalNotReceived();
6060 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
6062 application.SendNotification();
6063 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
6065 // We didn't expect the animation to finish yet
6066 application.SendNotification();
6067 finishCheck.CheckSignalNotReceived();
6068 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
6070 application.SendNotification();
6071 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
6073 // We did expect the animation to finish
6074 application.SendNotification();
6075 finishCheck.CheckSignalReceived();
6076 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
6080 int UtcDaliAnimationAnimateToVector4P(void)
6082 TestApplication application;
6084 Actor actor = Actor::New();
6086 // Register a Vector4 property
6087 Vector4 startValue(-50.0f, -40.0f, -30.0f, -20.0f);
6088 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
6089 Stage::GetCurrent().Add(actor);
6090 DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
6091 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
6093 // Build the animation
6094 float durationSeconds(2.0f);
6095 Animation animation = Animation::New(durationSeconds);
6096 Vector4 targetValue(50.0f, 50.0f, 50.0f, 50.0f);
6097 Vector4 relativeValue(targetValue - startValue);
6098 animation.AnimateTo(Property(actor, index), targetValue);
6100 Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
6102 // Start the animation
6105 bool signalReceived(false);
6106 AnimationFinishCheck finishCheck(signalReceived);
6107 animation.FinishedSignal().Connect(&application, finishCheck);
6109 application.SendNotification();
6110 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
6112 // We didn't expect the animation to finish yet
6113 application.SendNotification();
6114 finishCheck.CheckSignalNotReceived();
6115 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
6117 application.SendNotification();
6118 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
6120 // We did expect the animation to finish
6121 application.SendNotification();
6122 finishCheck.CheckSignalReceived();
6123 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
6127 int UtcDaliAnimationAnimateToVector4AlphaFunctionP(void)
6129 TestApplication application;
6131 Actor actor = Actor::New();
6133 // Register a Vector4 property
6134 Vector4 startValue(1000.0f, 1000.0f, 1000.0f, 1000.0f);
6135 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
6136 Stage::GetCurrent().Add(actor);
6137 DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
6138 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
6140 // Build the animation
6141 float durationSeconds(1.0f);
6142 Animation animation = Animation::New(durationSeconds);
6143 Vector4 targetValue(9000.0f, 9000.0f, 9000.0f, 9000.0f);
6144 Vector4 relativeValue(targetValue - startValue);
6145 animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
6147 Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
6149 // Start the animation
6152 bool signalReceived(false);
6153 AnimationFinishCheck finishCheck(signalReceived);
6154 animation.FinishedSignal().Connect(&application, finishCheck);
6156 application.SendNotification();
6157 application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
6159 // We didn't expect the animation to finish yet
6160 application.SendNotification();
6161 finishCheck.CheckSignalNotReceived();
6163 // The position should have moved more, than with a linear alpha function
6164 Vector4 current( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ) );
6165 DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
6166 DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
6167 DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
6168 DALI_TEST_CHECK( current.w > ninetyFivePercentProgress.w );
6170 application.SendNotification();
6171 application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
6173 // We did expect the animation to finish
6174 application.SendNotification();
6175 finishCheck.CheckSignalReceived();
6176 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
6180 int UtcDaliAnimationAnimateToVector4TimePeriodP(void)
6182 TestApplication application;
6184 Actor actor = Actor::New();
6186 // Register a Vector4 property
6187 Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
6188 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
6189 Stage::GetCurrent().Add(actor);
6190 DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
6191 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, VECTOR4_EPSILON, TEST_LOCATION );
6193 // Build the animation
6194 float durationSeconds(1.0f);
6195 Animation animation = Animation::New(durationSeconds);
6196 Vector4 targetValue(-10.0f, 20.0f, 100.0f, 100.0f);
6197 Vector4 relativeValue(targetValue - startValue);
6199 animation.AnimateTo(Property(actor, index),
6201 TimePeriod(delay, durationSeconds - delay));
6203 // Start the animation
6206 bool signalReceived(false);
6207 AnimationFinishCheck finishCheck(signalReceived);
6208 animation.FinishedSignal().Connect(&application, finishCheck);
6210 application.SendNotification();
6211 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
6213 // We didn't expect the animation to finish yet
6214 application.SendNotification();
6215 finishCheck.CheckSignalNotReceived();
6216 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, VECTOR4_EPSILON, TEST_LOCATION );
6218 application.SendNotification();
6219 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
6221 // We didn't expect the animation to finish yet
6222 application.SendNotification();
6223 finishCheck.CheckSignalNotReceived();
6224 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue+(relativeValue*0.5f), VECTOR4_EPSILON, TEST_LOCATION );
6226 application.SendNotification();
6227 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
6229 // We did expect the animation to finish
6230 application.SendNotification();
6231 finishCheck.CheckSignalReceived();
6232 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, VECTOR4_EPSILON, TEST_LOCATION );
6236 int UtcDaliAnimationAnimateToVector4AlphaFunctionTimePeriodP(void)
6238 TestApplication application;
6240 Actor actor = Actor::New();
6242 // Register a Vector4 property
6243 Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
6244 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
6245 Stage::GetCurrent().Add(actor);
6246 DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
6247 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
6249 // Build the animation
6250 float durationSeconds(1.0f);
6251 Animation animation = Animation::New(durationSeconds);
6252 Vector4 targetValue(30.0f, 30.0f, 30.0f, 30.0f);
6253 Vector4 relativeValue(targetValue - startValue);
6255 animation.AnimateTo(Property(actor, index),
6257 AlphaFunction::LINEAR,
6258 TimePeriod(delay, durationSeconds - delay));
6260 // Start the animation
6263 bool signalReceived(false);
6264 AnimationFinishCheck finishCheck(signalReceived);
6265 animation.FinishedSignal().Connect(&application, finishCheck);
6267 application.SendNotification();
6268 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
6270 // We didn't expect the animation to finish yet
6271 application.SendNotification();
6272 finishCheck.CheckSignalNotReceived();
6273 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
6275 application.SendNotification();
6276 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
6278 // We didn't expect the animation to finish yet
6279 application.SendNotification();
6280 finishCheck.CheckSignalNotReceived();
6281 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
6283 application.SendNotification();
6284 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
6286 // We did expect the animation to finish
6287 application.SendNotification();
6288 finishCheck.CheckSignalReceived();
6289 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
6293 int UtcDaliAnimationAnimateToActorParentOriginP(void)
6295 TestApplication application;
6297 Actor actor = Actor::New();
6298 Stage::GetCurrent().Add(actor);
6299 DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
6301 // Build the animation
6302 float durationSeconds(1.0f);
6303 Animation animation = Animation::New(durationSeconds);
6304 Vector3 targetParentOrigin(ParentOrigin::BOTTOM_RIGHT);
6308 animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN), targetParentOrigin );
6310 catch (Dali::DaliException& e)
6312 DALI_TEST_PRINT_ASSERT( e );
6313 DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6318 int UtcDaliAnimationAnimateToActorParentOriginXP(void)
6320 TestApplication application;
6322 Actor actor = Actor::New();
6323 Stage::GetCurrent().Add(actor);
6324 float startValue(0.0f);
6325 DALI_TEST_EQUALS( actor.GetCurrentParentOrigin().x, startValue, TEST_LOCATION );
6326 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_X), startValue, TEST_LOCATION );
6328 // Build the animation
6329 float durationSeconds(1.0f);
6330 Animation animation = Animation::New(durationSeconds);
6331 float targetX(1.0f);
6335 animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_X), targetX );
6337 catch (Dali::DaliException& e)
6339 DALI_TEST_PRINT_ASSERT( e );
6340 DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6345 int UtcDaliAnimationAnimateToActorParentOriginYP(void)
6347 TestApplication application;
6349 Actor actor = Actor::New();
6350 Stage::GetCurrent().Add(actor);
6351 float startValue(0.0f);
6352 DALI_TEST_EQUALS( actor.GetCurrentParentOrigin().y, startValue, TEST_LOCATION );
6353 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_Y), startValue, TEST_LOCATION );
6355 // Build the animation
6356 float durationSeconds(1.0f);
6357 Animation animation = Animation::New(durationSeconds);
6358 float targetY(1.0f);
6362 animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_Y), targetY );
6364 catch (Dali::DaliException& e)
6366 DALI_TEST_PRINT_ASSERT( e );
6367 DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6372 int UtcDaliAnimationAnimateToActorParentOriginZP(void)
6374 TestApplication application;
6376 Actor actor = Actor::New();
6377 Stage::GetCurrent().Add(actor);
6378 float startValue(0.5f);
6379 DALI_TEST_EQUALS( actor.GetCurrentParentOrigin().z, startValue, TEST_LOCATION );
6380 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_Z), startValue, TEST_LOCATION );
6382 // Build the animation
6383 float durationSeconds(1.0f);
6384 Animation animation = Animation::New(durationSeconds);
6385 float targetZ(1.0f);
6389 animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_Z), targetZ );
6391 catch (Dali::DaliException& e)
6393 DALI_TEST_PRINT_ASSERT( e );
6394 DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6399 int UtcDaliAnimationAnimateToActorAnchorPointP(void)
6401 TestApplication application;
6403 Actor actor = Actor::New();
6404 Stage::GetCurrent().Add(actor);
6405 DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), AnchorPoint::CENTER, TEST_LOCATION );
6407 // Build the animation
6408 float durationSeconds(1.0f);
6409 Animation animation = Animation::New(durationSeconds);
6410 Vector3 targetAnchorPoint(AnchorPoint::TOP_LEFT);
6414 animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT), targetAnchorPoint);
6416 catch (Dali::DaliException& e)
6418 DALI_TEST_PRINT_ASSERT( e );
6419 DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6424 int UtcDaliAnimationAnimateToActorAnchorPointXP(void)
6426 TestApplication application;
6428 Actor actor = Actor::New();
6429 Stage::GetCurrent().Add(actor);
6430 float startValue(0.5f);
6431 DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint().x, startValue, TEST_LOCATION );
6432 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_X), startValue, TEST_LOCATION );
6434 // Build the animation
6435 float durationSeconds(1.0f);
6436 Animation animation = Animation::New(durationSeconds);
6437 float targetX(1.0f);
6441 animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_X), targetX );
6443 catch (Dali::DaliException& e)
6445 DALI_TEST_PRINT_ASSERT( e );
6446 DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6451 int UtcDaliAnimationAnimateToActorAnchorPointYP(void)
6453 TestApplication application;
6455 Actor actor = Actor::New();
6456 Stage::GetCurrent().Add(actor);
6457 float startValue(0.5f);
6458 DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint().y, startValue, TEST_LOCATION );
6459 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_Y), startValue, TEST_LOCATION );
6461 // Build the animation
6462 float durationSeconds(1.0f);
6463 Animation animation = Animation::New(durationSeconds);
6464 float targetY(0.0f);
6468 animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_Y), targetY );
6470 catch (Dali::DaliException& e)
6472 DALI_TEST_PRINT_ASSERT( e );
6473 DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6478 int UtcDaliAnimationAnimateToActorAnchorPointZP(void)
6480 TestApplication application;
6482 Actor actor = Actor::New();
6483 Stage::GetCurrent().Add(actor);
6484 float startValue(0.5f);
6485 DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint().z, startValue, TEST_LOCATION );
6486 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_Z), startValue, TEST_LOCATION );
6488 // Build the animation
6489 float durationSeconds(1.0f);
6490 Animation animation = Animation::New(durationSeconds);
6491 float targetZ(100.0f);
6495 animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_Z), targetZ );
6497 catch (Dali::DaliException& e)
6499 DALI_TEST_PRINT_ASSERT( e );
6500 DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6505 int UtcDaliAnimationAnimateToActorSizeP(void)
6507 TestApplication application;
6509 Actor actor = Actor::New();
6510 Stage::GetCurrent().Add(actor);
6511 DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6513 // Build the animation
6514 float durationSeconds(1.0f);
6515 Animation animation = Animation::New(durationSeconds);
6516 Vector3 targetSize(100.0f, 100.0f, 100.0f);
6517 animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize );
6519 Vector3 ninetyNinePercentProgress(targetSize * 0.99f);
6521 // Start the animation
6524 bool signalReceived(false);
6525 AnimationFinishCheck finishCheck(signalReceived);
6526 animation.FinishedSignal().Connect(&application, finishCheck);
6528 application.SendNotification();
6529 application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
6531 // We didn't expect the animation to finish yet
6532 application.SendNotification();
6533 finishCheck.CheckSignalNotReceived();
6534 DALI_TEST_EQUALS( actor.GetCurrentSize(), ninetyNinePercentProgress, TEST_LOCATION );
6536 application.SendNotification();
6537 application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
6539 // We did expect the animation to finish
6540 application.SendNotification();
6541 finishCheck.CheckSignalReceived();
6542 DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
6545 finishCheck.Reset();
6546 actor.SetSize(Vector3::ZERO);
6547 application.SendNotification();
6548 application.Render(0);
6549 DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6551 // Repeat with a different (ease-in) alpha function
6552 animation = Animation::New(durationSeconds);
6553 animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::EASE_IN);
6554 animation.FinishedSignal().Connect(&application, finishCheck);
6557 application.SendNotification();
6558 application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
6560 // We didn't expect the animation to finish yet
6561 application.SendNotification();
6562 finishCheck.CheckSignalNotReceived();
6564 // The size should have travelled less, than with a linear alpha function
6565 Vector3 current(actor.GetCurrentSize());
6566 DALI_TEST_CHECK( current.x > 0.0f );
6567 DALI_TEST_CHECK( current.y > 0.0f );
6568 DALI_TEST_CHECK( current.z > 0.0f );
6569 DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
6570 DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
6571 DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
6573 application.SendNotification();
6574 application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
6576 // We did expect the animation to finish
6577 application.SendNotification();
6578 finishCheck.CheckSignalReceived();
6579 DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
6582 finishCheck.Reset();
6583 actor.SetSize(Vector3::ZERO);
6584 application.SendNotification();
6585 application.Render(0);
6586 DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6588 // Repeat with a delay
6590 animation = Animation::New(durationSeconds);
6591 animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
6592 animation.FinishedSignal().Connect(&application, finishCheck);
6595 application.SendNotification();
6596 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
6598 // We didn't expect the animation to finish yet
6599 application.SendNotification();
6600 finishCheck.CheckSignalNotReceived();
6601 DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6603 application.SendNotification();
6604 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6606 // We did expect the animation to finish
6607 application.SendNotification();
6608 finishCheck.CheckSignalReceived();
6609 DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
6613 int UtcDaliAnimationAnimateToActorSizeWidthP(void)
6615 TestApplication application;
6617 Actor actor = Actor::New();
6618 Stage::GetCurrent().Add(actor);
6619 float startValue(0.0f);
6620 DALI_TEST_EQUALS( actor.GetCurrentSize().width, startValue, TEST_LOCATION );
6621 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), startValue, TEST_LOCATION );
6623 // Build the animation
6624 float durationSeconds(1.0f);
6625 Animation animation = Animation::New(durationSeconds);
6626 float targetWidth(10.0f);
6627 animation.AnimateTo( Property(actor, Actor::Property::SIZE_WIDTH), targetWidth );
6629 float fiftyPercentProgress(startValue + (targetWidth - startValue)*0.5f);
6631 // Start the animation
6634 bool signalReceived(false);
6635 AnimationFinishCheck finishCheck(signalReceived);
6636 animation.FinishedSignal().Connect(&application, finishCheck);
6638 application.SendNotification();
6639 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
6641 // We didn't expect the animation to finish yet
6642 application.SendNotification();
6643 finishCheck.CheckSignalNotReceived();
6644 DALI_TEST_EQUALS( actor.GetCurrentSize().width, fiftyPercentProgress, TEST_LOCATION );
6646 application.SendNotification();
6647 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6649 // We did expect the animation to finish
6650 application.SendNotification();
6651 finishCheck.CheckSignalReceived();
6652 DALI_TEST_EQUALS( actor.GetCurrentSize().width, targetWidth, TEST_LOCATION );
6653 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetWidth, TEST_LOCATION );
6657 int UtcDaliAnimationAnimateToActorSizeHeightP(void)
6659 TestApplication application;
6661 Actor actor = Actor::New();
6662 Stage::GetCurrent().Add(actor);
6663 float startValue(0.0f);
6664 DALI_TEST_EQUALS( actor.GetCurrentSize().height, startValue, TEST_LOCATION );
6665 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), startValue, TEST_LOCATION );
6667 // Build the animation
6668 float durationSeconds(1.0f);
6669 Animation animation = Animation::New(durationSeconds);
6670 float targetHeight(-10.0f);
6671 animation.AnimateTo( Property(actor, Actor::Property::SIZE_HEIGHT), targetHeight );
6673 float fiftyPercentProgress(startValue + (targetHeight - startValue)*0.5f);
6675 // Start the animation
6678 bool signalReceived(false);
6679 AnimationFinishCheck finishCheck(signalReceived);
6680 animation.FinishedSignal().Connect(&application, finishCheck);
6682 application.SendNotification();
6683 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
6685 // We didn't expect the animation to finish yet
6686 application.SendNotification();
6687 finishCheck.CheckSignalNotReceived();
6688 DALI_TEST_EQUALS( actor.GetCurrentSize().height, fiftyPercentProgress, TEST_LOCATION );
6690 application.SendNotification();
6691 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6693 // We did expect the animation to finish
6694 application.SendNotification();
6695 finishCheck.CheckSignalReceived();
6696 DALI_TEST_EQUALS( actor.GetCurrentSize().height, targetHeight, TEST_LOCATION );
6697 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetHeight, TEST_LOCATION );
6701 int UtcDaliAnimationAnimateToActorSizeDepthP(void)
6703 TestApplication application;
6705 Actor actor = Actor::New();
6706 Stage::GetCurrent().Add(actor);
6707 float startValue(0.0f);
6708 DALI_TEST_EQUALS( actor.GetCurrentSize().depth, startValue, TEST_LOCATION );
6709 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), startValue, TEST_LOCATION );
6711 // Build the animation
6712 float durationSeconds(1.0f);
6713 Animation animation = Animation::New(durationSeconds);
6714 float targetDepth(-10.0f);
6715 animation.AnimateTo( Property(actor, Actor::Property::SIZE_DEPTH), targetDepth );
6717 float fiftyPercentProgress(startValue + (targetDepth - startValue)*0.5f);
6719 // Start the animation
6722 bool signalReceived(false);
6723 AnimationFinishCheck finishCheck(signalReceived);
6724 animation.FinishedSignal().Connect(&application, finishCheck);
6726 application.SendNotification();
6727 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
6729 // We didn't expect the animation to finish yet
6730 application.SendNotification();
6731 finishCheck.CheckSignalNotReceived();
6732 DALI_TEST_EQUALS( actor.GetCurrentSize().depth, fiftyPercentProgress, TEST_LOCATION );
6734 application.SendNotification();
6735 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6737 // We did expect the animation to finish
6738 application.SendNotification();
6739 finishCheck.CheckSignalReceived();
6740 DALI_TEST_EQUALS( actor.GetCurrentSize().depth, targetDepth, TEST_LOCATION );
6741 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetDepth, TEST_LOCATION );
6745 int UtcDaliAnimationAnimateToActorSizeWidthHeightP(void)
6747 TestApplication application;
6749 Actor actor = Actor::New();
6750 Stage::GetCurrent().Add(actor);
6751 DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6753 // Build the animation
6754 float durationSeconds(1.0f);
6755 Animation animation = Animation::New(durationSeconds);
6756 Vector3 targetSize(100.0f, 100.0f, 100.0f);
6757 animation.AnimateTo( Property( actor, Actor::Property::SIZE ), targetSize );
6759 Vector3 ninetyNinePercentProgress(targetSize * 0.99f);
6761 // Start the animation
6764 bool signalReceived(false);
6765 AnimationFinishCheck finishCheck(signalReceived);
6766 animation.FinishedSignal().Connect(&application, finishCheck);
6768 application.SendNotification();
6769 application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
6771 // We didn't expect the animation to finish yet
6772 application.SendNotification();
6773 finishCheck.CheckSignalNotReceived();
6774 DALI_TEST_EQUALS( actor.GetCurrentSize(), ninetyNinePercentProgress, TEST_LOCATION );
6776 application.SendNotification();
6777 application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
6779 // We did expect the animation to finish
6780 application.SendNotification();
6781 finishCheck.CheckSignalReceived();
6782 DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
6785 finishCheck.Reset();
6786 actor.SetSize(Vector3::ZERO);
6787 application.SendNotification();
6788 application.Render(0);
6789 DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6791 // Repeat with a different (ease-in) alpha function
6792 animation = Animation::New(durationSeconds);
6793 animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunction::EASE_IN );
6794 animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunction::EASE_IN );
6795 animation.FinishedSignal().Connect(&application, finishCheck);
6798 application.SendNotification();
6799 application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
6801 // We didn't expect the animation to finish yet
6802 application.SendNotification();
6803 finishCheck.CheckSignalNotReceived();
6805 // The size should have travelled less, than with a linear alpha function
6806 Vector3 current(actor.GetCurrentSize());
6807 DALI_TEST_CHECK( current.x > 0.0f );
6808 DALI_TEST_CHECK( current.y > 0.0f );
6809 DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
6810 DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
6812 application.SendNotification();
6813 application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
6815 // We did expect the animation to finish
6816 application.SendNotification();
6817 finishCheck.CheckSignalReceived();
6818 DALI_TEST_EQUALS( actor.GetCurrentSize().x, targetSize.x, TEST_LOCATION );
6819 DALI_TEST_EQUALS( actor.GetCurrentSize().y, targetSize.y, TEST_LOCATION );
6822 finishCheck.Reset();
6823 actor.SetSize(Vector3::ZERO);
6824 application.SendNotification();
6825 application.Render(0);
6826 DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6828 // Repeat with a delay
6830 animation = Animation::New(durationSeconds);
6831 animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
6832 animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
6833 animation.FinishedSignal().Connect(&application, finishCheck);
6836 application.SendNotification();
6837 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
6839 // We didn't expect the animation to finish yet
6840 application.SendNotification();
6841 finishCheck.CheckSignalNotReceived();
6842 DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6844 application.SendNotification();
6845 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6847 // We did expect the animation to finish
6848 application.SendNotification();
6849 finishCheck.CheckSignalReceived();
6850 DALI_TEST_EQUALS( actor.GetCurrentSize().x, targetSize.x, TEST_LOCATION );
6851 DALI_TEST_EQUALS( actor.GetCurrentSize().y, targetSize.y, TEST_LOCATION );
6855 int UtcDaliAnimationAnimateToActorPositionP(void)
6857 TestApplication application;
6859 Actor actor = Actor::New();
6860 Stage::GetCurrent().Add(actor);
6861 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
6863 // Build the animation
6864 float durationSeconds(1.0f);
6865 Animation animation = Animation::New(durationSeconds);
6866 Vector3 targetPosition(200.0f, 200.0f, 200.0f);
6867 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
6869 Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
6871 // Start the animation
6874 bool signalReceived(false);
6875 AnimationFinishCheck finishCheck(signalReceived);
6876 animation.FinishedSignal().Connect(&application, finishCheck);
6878 application.SendNotification();
6879 application.Render(static_cast<unsigned int>(durationSeconds*750.0f)/* 75% progress */);
6881 // We didn't expect the animation to finish yet
6882 application.SendNotification();
6883 finishCheck.CheckSignalNotReceived();
6884 DALI_TEST_EQUALS( actor.GetCurrentPosition(), seventyFivePercentProgress, TEST_LOCATION );
6886 application.SendNotification();
6887 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
6889 // We did expect the animation to finish
6890 application.SendNotification();
6891 finishCheck.CheckSignalReceived();
6892 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
6896 int UtcDaliAnimationAnimateToActorPositionXP(void)
6898 TestApplication application;
6900 Actor actor = Actor::New();
6901 Stage::GetCurrent().Add(actor);
6902 float startValue(0.0f);
6903 DALI_TEST_EQUALS( actor.GetCurrentPosition().x, startValue, TEST_LOCATION );
6904 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
6905 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
6906 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
6908 // Build the animation
6909 float durationSeconds(1.0f);
6910 Animation animation = Animation::New(durationSeconds);
6911 float targetX(1.0f);
6912 animation.AnimateTo( Property(actor, Actor::Property::POSITION_X), targetX );
6914 float fiftyPercentProgress(startValue + (targetX - startValue)*0.5f);
6916 // Start the animation
6919 bool signalReceived(false);
6920 AnimationFinishCheck finishCheck(signalReceived);
6921 animation.FinishedSignal().Connect(&application, finishCheck);
6923 application.SendNotification();
6924 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
6926 // We didn't expect the animation to finish yet
6927 application.SendNotification();
6928 finishCheck.CheckSignalNotReceived();
6929 DALI_TEST_EQUALS( actor.GetCurrentPosition().x, fiftyPercentProgress, TEST_LOCATION );
6931 application.SendNotification();
6932 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6934 // We did expect the animation to finish
6935 application.SendNotification();
6936 finishCheck.CheckSignalReceived();
6937 DALI_TEST_EQUALS( actor.GetCurrentPosition().x, targetX, TEST_LOCATION );
6938 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetX, TEST_LOCATION );
6939 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
6940 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
6944 int UtcDaliAnimationAnimateToActorPositionYP(void)
6946 TestApplication application;
6948 Actor actor = Actor::New();
6949 Stage::GetCurrent().Add(actor);
6950 float startValue(0.0f);
6951 DALI_TEST_EQUALS( actor.GetCurrentPosition().y, startValue, TEST_LOCATION );
6952 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
6953 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
6954 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
6956 // Build the animation
6957 float durationSeconds(1.0f);
6958 Animation animation = Animation::New(durationSeconds);
6959 float targetY(10.0f);
6960 animation.AnimateTo( Property(actor, Actor::Property::POSITION_Y), targetY );
6962 float fiftyPercentProgress(startValue + (targetY - startValue)*0.5f);
6964 // Start the animation
6967 bool signalReceived(false);
6968 AnimationFinishCheck finishCheck(signalReceived);
6969 animation.FinishedSignal().Connect(&application, finishCheck);
6971 application.SendNotification();
6972 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
6974 // We didn't expect the animation to finish yet
6975 application.SendNotification();
6976 finishCheck.CheckSignalNotReceived();
6977 DALI_TEST_EQUALS( actor.GetCurrentPosition().y, fiftyPercentProgress, TEST_LOCATION );
6979 application.SendNotification();
6980 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6982 // We did expect the animation to finish
6983 application.SendNotification();
6984 finishCheck.CheckSignalReceived();
6985 DALI_TEST_EQUALS( actor.GetCurrentPosition().y, targetY, TEST_LOCATION );
6986 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
6987 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetY, TEST_LOCATION );
6988 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
6992 int UtcDaliAnimationAnimateToActorPositionZP(void)
6994 TestApplication application;
6996 Actor actor = Actor::New();
6997 Stage::GetCurrent().Add(actor);
6998 float startValue(0.0f);
6999 DALI_TEST_EQUALS( actor.GetCurrentPosition().z, startValue, TEST_LOCATION );
7000 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
7001 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
7002 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
7004 // Build the animation
7005 float durationSeconds(1.0f);
7006 Animation animation = Animation::New(durationSeconds);
7007 float targetZ(-5.0f);
7008 animation.AnimateTo( Property(actor, Actor::Property::POSITION_Z), targetZ );
7010 float fiftyPercentProgress(startValue + (targetZ - startValue)*0.5f);
7012 // Start the animation
7015 bool signalReceived(false);
7016 AnimationFinishCheck finishCheck(signalReceived);
7017 animation.FinishedSignal().Connect(&application, finishCheck);
7019 application.SendNotification();
7020 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7022 // We didn't expect the animation to finish yet
7023 application.SendNotification();
7024 finishCheck.CheckSignalNotReceived();
7025 DALI_TEST_EQUALS( actor.GetCurrentPosition().z, fiftyPercentProgress, TEST_LOCATION );
7027 application.SendNotification();
7028 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7030 // We did expect the animation to finish
7031 application.SendNotification();
7032 finishCheck.CheckSignalReceived();
7033 DALI_TEST_EQUALS( actor.GetCurrentPosition().z, targetZ, TEST_LOCATION );
7034 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
7035 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
7036 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetZ, TEST_LOCATION );
7040 int UtcDaliAnimationAnimateToActorPositionAlphaFunctionP(void)
7042 TestApplication application;
7044 Actor actor = Actor::New();
7045 Stage::GetCurrent().Add(actor);
7046 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
7048 // Build the animation
7049 float durationSeconds(1.0f);
7050 Animation animation = Animation::New(durationSeconds);
7051 Vector3 targetPosition(200.0f, 200.0f, 200.0f);
7052 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::EASE_IN);
7054 Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
7056 // Start the animation
7059 bool signalReceived(false);
7060 AnimationFinishCheck finishCheck(signalReceived);
7061 animation.FinishedSignal().Connect(&application, finishCheck);
7063 application.SendNotification();
7064 application.Render(static_cast<unsigned int>(durationSeconds*750.0f)/* 75% progress */);
7066 // We didn't expect the animation to finish yet
7067 application.SendNotification();
7068 finishCheck.CheckSignalNotReceived();
7070 // The position should have moved less, than with a linear alpha function
7071 Vector3 current(actor.GetCurrentPosition());
7072 DALI_TEST_CHECK( current.x > Vector3::ZERO.x );
7073 DALI_TEST_CHECK( current.y > Vector3::ZERO.y );
7074 DALI_TEST_CHECK( current.z > Vector3::ZERO.z );
7075 DALI_TEST_CHECK( current.x < seventyFivePercentProgress.x );
7076 DALI_TEST_CHECK( current.y < seventyFivePercentProgress.y );
7077 DALI_TEST_CHECK( current.z < seventyFivePercentProgress.z );
7079 application.SendNotification();
7080 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7082 // We did expect the animation to finish
7083 application.SendNotification();
7084 finishCheck.CheckSignalReceived();
7085 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
7089 int UtcDaliAnimationAnimateToActorPositionTimePeriodP(void)
7091 TestApplication application;
7093 Actor actor = Actor::New();
7094 Stage::GetCurrent().Add(actor);
7095 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
7097 // Build the animation
7098 float durationSeconds(1.0f);
7099 Animation animation = Animation::New(durationSeconds);
7100 Vector3 targetPosition(200.0f, 200.0f, 200.0f);
7102 animation.AnimateTo( Property(actor, Actor::Property::POSITION),
7104 TimePeriod( delay, durationSeconds - delay ) );
7106 Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
7108 // Start the animation
7111 bool signalReceived(false);
7112 AnimationFinishCheck finishCheck(signalReceived);
7113 animation.FinishedSignal().Connect(&application, finishCheck);
7115 application.SendNotification();
7116 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
7118 // We didn't expect the animation to finish yet
7119 application.SendNotification();
7120 finishCheck.CheckSignalNotReceived();
7121 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
7123 application.SendNotification();
7124 application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.75)/* 7/8 animation progress, 3/4 animator progress */);
7126 // We didn't expect the animation to finish yet
7127 application.SendNotification();
7128 finishCheck.CheckSignalNotReceived();
7129 DALI_TEST_EQUALS( actor.GetCurrentPosition(), seventyFivePercentProgress, TEST_LOCATION );
7131 application.SendNotification();
7132 application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.25) + 1u/*just beyond the animation duration*/);
7134 // We did expect the animation to finish
7135 application.SendNotification();
7136 finishCheck.CheckSignalReceived();
7137 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
7141 int UtcDaliAnimationAnimateToActorPositionAlphaFunctionTimePeriodP(void)
7143 TestApplication application;
7145 Actor actor = Actor::New();
7146 Stage::GetCurrent().Add(actor);
7147 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
7149 // Build the animation
7150 float durationSeconds(1.0f);
7151 Animation animation = Animation::New(durationSeconds);
7152 Vector3 targetPosition(200.0f, 200.0f, 200.0f);
7154 animation.AnimateTo( Property(actor, Actor::Property::POSITION),
7156 AlphaFunction::LINEAR,
7157 TimePeriod( delay, durationSeconds - delay ) );
7159 Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
7161 // Start the animation
7164 bool signalReceived(false);
7165 AnimationFinishCheck finishCheck(signalReceived);
7166 animation.FinishedSignal().Connect(&application, finishCheck);
7168 application.SendNotification();
7169 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
7171 // We didn't expect the animation to finish yet
7172 application.SendNotification();
7173 finishCheck.CheckSignalNotReceived();
7174 DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
7176 application.SendNotification();
7177 application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.75)/* 7/8 animation progress, 3/4 animator progress */);
7179 // We didn't expect the animation to finish yet
7180 application.SendNotification();
7181 finishCheck.CheckSignalNotReceived();
7182 DALI_TEST_EQUALS( actor.GetCurrentPosition(), seventyFivePercentProgress, TEST_LOCATION );
7184 application.SendNotification();
7185 application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.25) + 1u/*just beyond the animation duration*/);
7187 // We did expect the animation to finish
7188 application.SendNotification();
7189 finishCheck.CheckSignalReceived();
7190 DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
7194 int UtcDaliAnimationAnimateToActorOrientationAngleAxisP(void)
7196 TestApplication application;
7198 Actor actor = Actor::New();
7199 actor.SetOrientation(Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
7200 Stage::GetCurrent().Add(actor);
7201 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
7203 // Build the animation
7204 float durationSeconds(1.0f);
7205 Animation animation = Animation::New(durationSeconds);
7206 Degree targetRotationDegrees(90.0f);
7207 Radian targetRotationRadians(targetRotationDegrees);
7208 animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationRadians, Vector3::YAXIS) );
7210 // Start the animation
7213 bool signalReceived(false);
7214 AnimationFinishCheck finishCheck(signalReceived);
7215 animation.FinishedSignal().Connect(&application, finishCheck);
7217 application.SendNotification();
7218 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
7220 // We didn't expect the animation to finish yet
7221 application.SendNotification();
7222 finishCheck.CheckSignalNotReceived();
7223 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7225 application.SendNotification();
7226 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
7228 // We didn't expect the animation to finish yet
7229 application.SendNotification();
7230 finishCheck.CheckSignalNotReceived();
7231 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7233 application.SendNotification();
7234 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
7236 // We didn't expect the animation to finish yet
7237 application.SendNotification();
7238 finishCheck.CheckSignalNotReceived();
7239 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7241 application.SendNotification();
7242 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7244 // We did expect the animation to finish
7245 application.SendNotification();
7246 finishCheck.CheckSignalReceived();
7247 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7251 int UtcDaliAnimationAnimateToActorOrientationQuaternionP(void)
7253 TestApplication application;
7255 Actor actor = Actor::New();
7256 actor.SetOrientation(Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
7257 Stage::GetCurrent().Add(actor);
7258 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
7260 // Build the animation
7261 float durationSeconds(1.0f);
7262 Animation animation = Animation::New(durationSeconds);
7263 Degree targetRotationDegrees(90.0f);
7264 Radian targetRotationRadians(targetRotationDegrees);
7265 Quaternion targetRotation(targetRotationRadians, Vector3::YAXIS);
7266 animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), targetRotation );
7268 // Start the animation
7271 bool signalReceived(false);
7272 AnimationFinishCheck finishCheck(signalReceived);
7273 animation.FinishedSignal().Connect(&application, finishCheck);
7275 application.SendNotification();
7276 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
7278 // We didn't expect the animation to finish yet
7279 application.SendNotification();
7280 finishCheck.CheckSignalNotReceived();
7281 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7283 application.SendNotification();
7284 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
7286 // We didn't expect the animation to finish yet
7287 application.SendNotification();
7288 finishCheck.CheckSignalNotReceived();
7289 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7291 application.SendNotification();
7292 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
7294 // We didn't expect the animation to finish yet
7295 application.SendNotification();
7296 finishCheck.CheckSignalNotReceived();
7297 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7299 application.SendNotification();
7300 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7302 // We did expect the animation to finish
7303 application.SendNotification();
7304 finishCheck.CheckSignalReceived();
7305 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7309 int UtcDaliAnimationAnimateToActorOrientationAlphaFunctionP(void)
7311 TestApplication application;
7313 Actor actor = Actor::New();
7314 actor.SetOrientation(Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
7315 Stage::GetCurrent().Add(actor);
7316 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(Radian(0.0f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7318 // Build the animation
7319 float durationSeconds(1.0f);
7320 Animation animation = Animation::New(durationSeconds);
7321 Degree targetRotationDegrees(90.0f);
7322 Radian targetRotationRadians(targetRotationDegrees);
7323 animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN);
7325 // Start the animation
7328 bool signalReceived(false);
7329 AnimationFinishCheck finishCheck(signalReceived);
7330 animation.FinishedSignal().Connect(&application, finishCheck);
7332 application.SendNotification();
7333 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
7335 // We didn't expect the animation to finish yet
7336 application.SendNotification();
7337 finishCheck.CheckSignalNotReceived();
7338 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.25f*0.25f*0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7340 application.SendNotification();
7341 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
7343 // We didn't expect the animation to finish yet
7344 application.SendNotification();
7345 finishCheck.CheckSignalNotReceived();
7346 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.5f*0.5f*0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7348 application.SendNotification();
7349 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
7351 // We didn't expect the animation to finish yet
7352 application.SendNotification();
7353 finishCheck.CheckSignalNotReceived();
7354 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.75f*0.75f*0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7356 application.SendNotification();
7357 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7359 // We did expect the animation to finish
7360 application.SendNotification();
7361 finishCheck.CheckSignalReceived();
7362 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7366 int UtcDaliAnimationAnimateToActorOrientationTimePeriodP(void)
7368 TestApplication application;
7370 Actor actor = Actor::New();
7371 actor.SetOrientation(Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
7372 Stage::GetCurrent().Add(actor);
7373 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
7375 // Build the animation
7376 float durationSeconds(1.0f);
7377 Animation animation = Animation::New(durationSeconds);
7378 Degree targetRotationDegrees(90.0f);
7379 Radian targetRotationRadians(targetRotationDegrees);
7381 animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), TimePeriod(delay, durationSeconds - delay));
7383 // Start the animation
7386 bool signalReceived(false);
7387 AnimationFinishCheck finishCheck(signalReceived);
7388 animation.FinishedSignal().Connect(&application, finishCheck);
7390 application.SendNotification();
7391 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
7393 // We didn't expect the animation to finish yet
7394 application.SendNotification();
7395 finishCheck.CheckSignalNotReceived();
7396 float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
7397 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7399 application.SendNotification();
7400 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
7402 // We didn't expect the animation to finish yet
7403 application.SendNotification();
7404 finishCheck.CheckSignalNotReceived();
7405 progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
7406 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7408 application.SendNotification();
7409 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
7411 // We didn't expect the animation to finish yet
7412 application.SendNotification();
7413 finishCheck.CheckSignalNotReceived();
7414 progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
7415 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7417 application.SendNotification();
7418 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7420 // We did expect the animation to finish
7421 application.SendNotification();
7422 finishCheck.CheckSignalReceived();
7423 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7427 int UtcDaliAnimationAnimateToActorOrientationAlphaFunctionTimePeriodP(void)
7429 TestApplication application;
7431 Actor actor = Actor::New();
7432 actor.SetOrientation(Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
7433 Stage::GetCurrent().Add(actor);
7434 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
7436 // Build the animation
7437 float durationSeconds(1.0f);
7438 Animation animation = Animation::New(durationSeconds);
7439 Degree targetRotationDegrees(90.0f);
7440 Radian targetRotationRadians(targetRotationDegrees);
7442 animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN, TimePeriod(delay, durationSeconds - delay));
7444 // Start the animation
7447 bool signalReceived(false);
7448 AnimationFinishCheck finishCheck(signalReceived);
7449 animation.FinishedSignal().Connect(&application, finishCheck);
7451 application.SendNotification();
7452 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
7454 // We didn't expect the animation to finish yet
7455 application.SendNotification();
7456 finishCheck.CheckSignalNotReceived();
7457 float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
7458 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7460 application.SendNotification();
7461 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
7463 // We didn't expect the animation to finish yet
7464 application.SendNotification();
7465 finishCheck.CheckSignalNotReceived();
7466 progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
7467 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7469 application.SendNotification();
7470 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
7472 // We didn't expect the animation to finish yet
7473 application.SendNotification();
7474 finishCheck.CheckSignalNotReceived();
7475 progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
7476 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7478 application.SendNotification();
7479 application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7481 // We did expect the animation to finish
7482 application.SendNotification();
7483 finishCheck.CheckSignalReceived();
7484 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7488 int UtcDaliAnimationAnimateToActorScaleP(void)
7490 TestApplication application;
7492 Actor actor = Actor::New();
7493 Stage::GetCurrent().Add(actor);
7494 DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
7496 // Build the animation
7497 float durationSeconds(1.0f);
7498 Animation animation = Animation::New(durationSeconds);
7499 Vector3 targetScale(2.0f, 2.0f, 2.0f);
7500 animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale );
7502 Vector3 ninetyNinePercentProgress(Vector3::ONE + (targetScale - Vector3::ONE)*0.99f);
7504 // Start the animation
7507 bool signalReceived(false);
7508 AnimationFinishCheck finishCheck(signalReceived);
7509 animation.FinishedSignal().Connect(&application, finishCheck);
7511 application.SendNotification();
7512 application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
7514 // We didn't expect the animation to finish yet
7515 application.SendNotification();
7516 finishCheck.CheckSignalNotReceived();
7517 DALI_TEST_EQUALS( actor.GetCurrentScale(), ninetyNinePercentProgress, TEST_LOCATION );
7519 application.SendNotification();
7520 application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
7522 // We did expect the animation to finish
7523 application.SendNotification();
7524 finishCheck.CheckSignalReceived();
7525 DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
7528 finishCheck.Reset();
7529 actor.SetScale(Vector3::ONE);
7530 application.SendNotification();
7531 application.Render(0);
7532 DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
7534 // Repeat with a different (ease-in) alpha function
7535 animation = Animation::New(durationSeconds);
7536 animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::EASE_IN);
7537 animation.FinishedSignal().Connect(&application, finishCheck);
7540 application.SendNotification();
7541 application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
7543 // We didn't expect the animation to finish yet
7544 application.SendNotification();
7545 finishCheck.CheckSignalNotReceived();
7547 // The scale should have grown less, than with a linear alpha function
7548 Vector3 current(actor.GetCurrentScale());
7549 DALI_TEST_CHECK( current.x > 1.0f );
7550 DALI_TEST_CHECK( current.y > 1.0f );
7551 DALI_TEST_CHECK( current.z > 1.0f );
7552 DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
7553 DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
7554 DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
7556 application.SendNotification();
7557 application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
7559 // We did expect the animation to finish
7560 application.SendNotification();
7561 finishCheck.CheckSignalReceived();
7562 DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
7565 finishCheck.Reset();
7566 actor.SetScale(Vector3::ONE);
7567 application.SendNotification();
7568 application.Render(0);
7569 DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
7571 // Repeat with a delay
7573 animation = Animation::New(durationSeconds);
7574 animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
7575 animation.FinishedSignal().Connect(&application, finishCheck);
7578 application.SendNotification();
7579 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
7581 // We didn't expect the animation to finish yet
7582 application.SendNotification();
7583 finishCheck.CheckSignalNotReceived();
7584 DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
7586 application.SendNotification();
7587 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7589 // We did expect the animation to finish
7590 application.SendNotification();
7591 finishCheck.CheckSignalReceived();
7592 DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
7596 int UtcDaliAnimationAnimateToActorScaleXP(void)
7598 TestApplication application;
7600 Actor actor = Actor::New();
7601 Stage::GetCurrent().Add(actor);
7602 float startValue(1.0f);
7603 DALI_TEST_EQUALS( actor.GetCurrentScale().x, startValue, TEST_LOCATION );
7604 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7605 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7606 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7608 // Build the animation
7609 float durationSeconds(1.0f);
7610 Animation animation = Animation::New(durationSeconds);
7611 float targetX(10.0f);
7612 animation.AnimateTo( Property(actor, Actor::Property::SCALE_X), targetX );
7614 float fiftyPercentProgress(startValue + (targetX - startValue)*0.5f);
7616 // Start the animation
7619 bool signalReceived(false);
7620 AnimationFinishCheck finishCheck(signalReceived);
7621 animation.FinishedSignal().Connect(&application, finishCheck);
7623 application.SendNotification();
7624 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7626 // We didn't expect the animation to finish yet
7627 application.SendNotification();
7628 finishCheck.CheckSignalNotReceived();
7629 DALI_TEST_EQUALS( actor.GetCurrentScale().x, fiftyPercentProgress, TEST_LOCATION );
7630 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), fiftyPercentProgress, TEST_LOCATION );
7631 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7632 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7634 application.SendNotification();
7635 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7637 // We did expect the animation to finish
7638 application.SendNotification();
7639 finishCheck.CheckSignalReceived();
7640 DALI_TEST_EQUALS( actor.GetCurrentScale().x, targetX, TEST_LOCATION );
7641 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), targetX, TEST_LOCATION );
7642 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7643 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7647 int UtcDaliAnimationAnimateToActorScaleYP(void)
7649 TestApplication application;
7651 Actor actor = Actor::New();
7652 Stage::GetCurrent().Add(actor);
7653 float startValue(1.0f);
7654 DALI_TEST_EQUALS( actor.GetCurrentScale().y, startValue, TEST_LOCATION );
7655 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7656 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7657 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7659 // Build the animation
7660 float durationSeconds(1.0f);
7661 Animation animation = Animation::New(durationSeconds);
7662 float targetY(1000.0f);
7663 animation.AnimateTo( Property(actor, Actor::Property::SCALE_Y), targetY );
7665 float fiftyPercentProgress(startValue + (targetY - startValue)*0.5f);
7667 // Start the animation
7670 bool signalReceived(false);
7671 AnimationFinishCheck finishCheck(signalReceived);
7672 animation.FinishedSignal().Connect(&application, finishCheck);
7674 application.SendNotification();
7675 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7677 // We didn't expect the animation to finish yet
7678 application.SendNotification();
7679 finishCheck.CheckSignalNotReceived();
7680 DALI_TEST_EQUALS( actor.GetCurrentScale().y, fiftyPercentProgress, TEST_LOCATION );
7681 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7682 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), fiftyPercentProgress, TEST_LOCATION );
7683 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7685 application.SendNotification();
7686 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7688 // We did expect the animation to finish
7689 application.SendNotification();
7690 finishCheck.CheckSignalReceived();
7691 DALI_TEST_EQUALS( actor.GetCurrentScale().y, targetY, TEST_LOCATION );
7692 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7693 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), targetY, TEST_LOCATION );
7694 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7698 int UtcDaliAnimationAnimateToActorScaleZP(void)
7700 TestApplication application;
7702 Actor actor = Actor::New();
7703 Stage::GetCurrent().Add(actor);
7704 float startValue(1.0f);
7705 DALI_TEST_EQUALS( actor.GetCurrentScale().z, startValue, TEST_LOCATION );
7706 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7707 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7708 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7710 // Build the animation
7711 float durationSeconds(1.0f);
7712 Animation animation = Animation::New(durationSeconds);
7713 float targetZ(-1000.0f);
7714 animation.AnimateTo( Property(actor, Actor::Property::SCALE_Z), targetZ );
7716 float fiftyPercentProgress(startValue + (targetZ - startValue)*0.5f);
7718 // Start the animation
7721 bool signalReceived(false);
7722 AnimationFinishCheck finishCheck(signalReceived);
7723 animation.FinishedSignal().Connect(&application, finishCheck);
7725 application.SendNotification();
7726 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7728 // We didn't expect the animation to finish yet
7729 application.SendNotification();
7730 finishCheck.CheckSignalNotReceived();
7731 DALI_TEST_EQUALS( actor.GetCurrentScale().z, fiftyPercentProgress, TEST_LOCATION );
7732 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7733 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7734 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), fiftyPercentProgress, TEST_LOCATION );
7736 application.SendNotification();
7737 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7739 // We did expect the animation to finish
7740 application.SendNotification();
7741 finishCheck.CheckSignalReceived();
7742 DALI_TEST_EQUALS( actor.GetCurrentScale().z, targetZ, TEST_LOCATION );
7743 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7744 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7745 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), targetZ, TEST_LOCATION );
7749 int UtcDaliAnimationAnimateToActorColorP(void)
7751 TestApplication application;
7753 Actor actor = Actor::New();
7754 Stage::GetCurrent().Add(actor);
7755 DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
7757 // Build the animation
7758 float durationSeconds(1.0f);
7759 Animation animation = Animation::New(durationSeconds);
7760 Vector4 targetColor(Color::RED);
7761 animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor );
7763 Vector4 tenPercentProgress(Vector4(1.0f, 0.9f, 0.9f, 1.0f));
7764 Vector4 twentyPercentProgress(Vector4(1.0f, 0.8f, 0.8f, 1.0f));
7766 // Start the animation
7769 bool signalReceived(false);
7770 AnimationFinishCheck finishCheck(signalReceived);
7771 animation.FinishedSignal().Connect(&application, finishCheck);
7773 application.SendNotification();
7774 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
7776 // We didn't expect the animation to finish yet
7777 application.SendNotification();
7778 finishCheck.CheckSignalNotReceived();
7779 DALI_TEST_EQUALS( actor.GetCurrentColor(), tenPercentProgress, TEST_LOCATION );
7781 application.SendNotification();
7782 application.Render(static_cast<unsigned int>(durationSeconds*900.0f) + 1u/*just beyond the animation duration*/);
7784 // We did expect the animation to finish
7785 application.SendNotification();
7786 finishCheck.CheckSignalReceived();
7787 DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
7790 finishCheck.Reset();
7791 actor.SetColor(Color::WHITE);
7792 application.SendNotification();
7793 application.Render(0);
7794 DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
7796 // Repeat with a different (ease-in) alpha function
7797 animation = Animation::New(durationSeconds);
7798 animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::EASE_IN);
7799 animation.FinishedSignal().Connect(&application, finishCheck);
7802 application.SendNotification();
7803 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
7805 // We didn't expect the animation to finish yet
7806 application.SendNotification();
7807 finishCheck.CheckSignalNotReceived();
7809 // The color should have changed less, than with a linear alpha function
7810 Vector4 current(actor.GetCurrentColor());
7811 DALI_TEST_CHECK( current.x == 1.0f ); // doesn't change
7812 DALI_TEST_CHECK( current.y < 1.0f );
7813 DALI_TEST_CHECK( current.y > tenPercentProgress.y );
7814 DALI_TEST_CHECK( current.z < 1.0f );
7815 DALI_TEST_CHECK( current.z > tenPercentProgress.z );
7816 DALI_TEST_CHECK( current.w == 1.0f ); // doesn't change
7818 application.SendNotification();
7819 application.Render(static_cast<unsigned int>(durationSeconds*900.0f) + 1u/*just beyond the animation duration*/);
7821 // We did expect the animation to finish
7822 application.SendNotification();
7823 finishCheck.CheckSignalReceived();
7824 DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
7827 finishCheck.Reset();
7828 actor.SetColor(Color::WHITE);
7829 application.SendNotification();
7830 application.Render(0);
7831 DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
7833 // Repeat with a shorter animator duration
7834 float animatorDuration = 0.5f;
7835 animation = Animation::New(durationSeconds);
7836 animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::LINEAR, TimePeriod(animatorDuration));
7837 animation.FinishedSignal().Connect(&application, finishCheck);
7840 application.SendNotification();
7841 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% animation progress, 20% animator progress */);
7843 // We didn't expect the animation to finish yet
7844 application.SendNotification();
7845 finishCheck.CheckSignalNotReceived();
7846 DALI_TEST_EQUALS( actor.GetCurrentColor(), twentyPercentProgress, TEST_LOCATION );
7848 application.SendNotification();
7849 application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 50% animation progress, 100% animator progress */);
7851 // We didn't expect the animation to finish yet
7852 application.SendNotification();
7853 finishCheck.CheckSignalNotReceived();
7854 DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
7856 application.SendNotification();
7857 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7859 // We did expect the animation to finish
7860 application.SendNotification();
7861 finishCheck.CheckSignalReceived();
7862 DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
7866 int UtcDaliAnimationAnimateToActorColorRedP(void)
7868 TestApplication application;
7870 Actor actor = Actor::New();
7871 Stage::GetCurrent().Add(actor);
7872 float startValue(1.0f);
7873 DALI_TEST_EQUALS( actor.GetCurrentColor().r, startValue, TEST_LOCATION );
7874 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
7875 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
7876 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
7877 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7879 // Build the animation
7880 float durationSeconds(1.0f);
7881 Animation animation = Animation::New(durationSeconds);
7882 float targetRed(0.5f);
7883 animation.AnimateTo( Property(actor, Actor::Property::COLOR_RED), targetRed );
7885 float fiftyPercentProgress(startValue + (targetRed - startValue)*0.5f);
7887 // Start the animation
7890 bool signalReceived(false);
7891 AnimationFinishCheck finishCheck(signalReceived);
7892 animation.FinishedSignal().Connect(&application, finishCheck);
7894 application.SendNotification();
7895 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7897 // We didn't expect the animation to finish yet
7898 application.SendNotification();
7899 finishCheck.CheckSignalNotReceived();
7900 DALI_TEST_EQUALS( actor.GetCurrentColor().r, fiftyPercentProgress, TEST_LOCATION );
7901 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), fiftyPercentProgress, TEST_LOCATION );
7902 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
7903 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
7904 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7906 application.SendNotification();
7907 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7909 // We did expect the animation to finish
7910 application.SendNotification();
7911 finishCheck.CheckSignalReceived();
7912 DALI_TEST_EQUALS( actor.GetCurrentColor().r, targetRed, TEST_LOCATION );
7913 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), targetRed, TEST_LOCATION );
7914 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
7915 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
7916 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7920 int UtcDaliAnimationAnimateToActorColorGreenP(void)
7922 TestApplication application;
7924 Actor actor = Actor::New();
7925 Stage::GetCurrent().Add(actor);
7926 float startValue(1.0f);
7927 DALI_TEST_EQUALS( actor.GetCurrentColor().g, startValue, TEST_LOCATION );
7928 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
7929 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
7930 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
7931 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7933 // Build the animation
7934 float durationSeconds(1.0f);
7935 Animation animation = Animation::New(durationSeconds);
7936 float targetGreen(0.5f);
7937 animation.AnimateTo( Property(actor, Actor::Property::COLOR_GREEN), targetGreen );
7939 float fiftyPercentProgress(startValue + (targetGreen - startValue)*0.5f);
7941 // Start the animation
7944 bool signalReceived(false);
7945 AnimationFinishCheck finishCheck(signalReceived);
7946 animation.FinishedSignal().Connect(&application, finishCheck);
7948 application.SendNotification();
7949 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7951 // We didn't expect the animation to finish yet
7952 application.SendNotification();
7953 finishCheck.CheckSignalNotReceived();
7954 DALI_TEST_EQUALS( actor.GetCurrentColor().g, fiftyPercentProgress, TEST_LOCATION );
7955 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
7956 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), fiftyPercentProgress, TEST_LOCATION );
7957 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
7958 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7960 application.SendNotification();
7961 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7963 // We did expect the animation to finish
7964 application.SendNotification();
7965 finishCheck.CheckSignalReceived();
7966 DALI_TEST_EQUALS( actor.GetCurrentColor().g, targetGreen, TEST_LOCATION );
7967 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
7968 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), targetGreen, TEST_LOCATION );
7969 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
7970 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7974 int UtcDaliAnimationAnimateToActorColorBlueP(void)
7976 TestApplication application;
7978 Actor actor = Actor::New();
7979 Stage::GetCurrent().Add(actor);
7980 float startValue(1.0f);
7981 DALI_TEST_EQUALS( actor.GetCurrentColor().b, startValue, TEST_LOCATION );
7982 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
7983 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
7984 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
7985 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7987 // Build the animation
7988 float durationSeconds(1.0f);
7989 Animation animation = Animation::New(durationSeconds);
7990 float targetBlue(0.5f);
7991 animation.AnimateTo( Property(actor, Actor::Property::COLOR_BLUE), targetBlue );
7993 float fiftyPercentProgress(startValue + (targetBlue - startValue)*0.5f);
7995 // Start the animation
7998 bool signalReceived(false);
7999 AnimationFinishCheck finishCheck(signalReceived);
8000 animation.FinishedSignal().Connect(&application, finishCheck);
8002 application.SendNotification();
8003 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
8005 // We didn't expect the animation to finish yet
8006 application.SendNotification();
8007 finishCheck.CheckSignalNotReceived();
8008 DALI_TEST_EQUALS( actor.GetCurrentColor().b, fiftyPercentProgress, TEST_LOCATION );
8009 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8010 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8011 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), fiftyPercentProgress, TEST_LOCATION );
8012 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8014 application.SendNotification();
8015 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
8017 // We did expect the animation to finish
8018 application.SendNotification();
8019 finishCheck.CheckSignalReceived();
8020 DALI_TEST_EQUALS( actor.GetCurrentColor().b, targetBlue, TEST_LOCATION );
8021 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8022 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8023 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), targetBlue, TEST_LOCATION );
8024 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8028 int UtcDaliAnimationAnimateToActorColorAlphaP(void)
8030 TestApplication application;
8032 Actor actor = Actor::New();
8033 Stage::GetCurrent().Add(actor);
8034 float startValue(1.0f);
8035 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8036 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8037 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8038 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8039 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8041 // Build the animation
8042 float durationSeconds(1.0f);
8043 Animation animation = Animation::New(durationSeconds);
8044 float targetAlpha(0.5f);
8045 animation.AnimateTo( Property(actor, Actor::Property::COLOR_ALPHA), targetAlpha );
8047 float fiftyPercentProgress(startValue + (targetAlpha - startValue)*0.5f);
8049 // Start the animation
8052 bool signalReceived(false);
8053 AnimationFinishCheck finishCheck(signalReceived);
8054 animation.FinishedSignal().Connect(&application, finishCheck);
8056 application.SendNotification();
8057 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
8059 // We didn't expect the animation to finish yet
8060 application.SendNotification();
8061 finishCheck.CheckSignalNotReceived();
8062 DALI_TEST_EQUALS( actor.GetCurrentColor().a, fiftyPercentProgress, TEST_LOCATION );
8063 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8064 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8065 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8066 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), fiftyPercentProgress, TEST_LOCATION );
8068 application.SendNotification();
8069 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
8071 // We did expect the animation to finish
8072 application.SendNotification();
8073 finishCheck.CheckSignalReceived();
8074 DALI_TEST_EQUALS( actor.GetCurrentColor().a, targetAlpha, TEST_LOCATION );
8075 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8076 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8077 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8078 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), targetAlpha, TEST_LOCATION );
8082 int UtcDaliAnimationKeyFrames01P(void)
8084 TestApplication application;
8086 KeyFrames keyFrames = KeyFrames::New();
8087 DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8089 keyFrames.Add(0.0f, 0.1f);
8091 DALI_TEST_EQUALS(keyFrames.GetType(), Property::FLOAT, TEST_LOCATION);
8093 KeyFrames keyFrames2( keyFrames);
8094 DALI_TEST_CHECK( keyFrames2 );
8095 DALI_TEST_EQUALS(keyFrames2.GetType(), Property::FLOAT, TEST_LOCATION);
8097 KeyFrames keyFrames3 = KeyFrames::New();
8098 keyFrames3.Add(0.6f, true);
8099 DALI_TEST_CHECK( keyFrames3 );
8100 DALI_TEST_EQUALS(keyFrames3.GetType(), Property::BOOLEAN, TEST_LOCATION);
8102 keyFrames3 = keyFrames;
8103 DALI_TEST_CHECK( keyFrames3 );
8104 DALI_TEST_EQUALS(keyFrames3.GetType(), Property::FLOAT, TEST_LOCATION);
8109 int UtcDaliAnimationKeyFrames02P(void)
8111 TestApplication application;
8113 KeyFrames keyFrames = KeyFrames::New();
8114 DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8116 keyFrames.Add(0.0f, 0.1f);
8117 keyFrames.Add(0.2f, 0.5f);
8118 keyFrames.Add(0.4f, 0.0f);
8119 keyFrames.Add(0.6f, 1.0f);
8120 keyFrames.Add(0.8f, 0.7f);
8121 keyFrames.Add(1.0f, 0.9f);
8123 DALI_TEST_EQUALS(keyFrames.GetType(), Property::FLOAT, TEST_LOCATION);
8127 keyFrames.Add(1.9f, false);
8129 catch (Dali::DaliException& e)
8131 DALI_TEST_PRINT_ASSERT( e );
8132 DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8137 int UtcDaliAnimationKeyFrames03P(void)
8139 TestApplication application;
8141 KeyFrames keyFrames = KeyFrames::New();
8142 DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8144 keyFrames.Add(0.0f, true);
8145 keyFrames.Add(0.2f, false);
8146 keyFrames.Add(0.4f, false);
8147 keyFrames.Add(0.6f, true);
8148 keyFrames.Add(0.8f, true);
8149 keyFrames.Add(1.0f, false);
8151 DALI_TEST_EQUALS(keyFrames.GetType(), Property::BOOLEAN, TEST_LOCATION);
8155 keyFrames.Add(0.7f, Vector3(1.0f, 1.0f, 1.0f));
8157 catch (Dali::DaliException& e)
8159 DALI_TEST_PRINT_ASSERT( e );
8160 DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8165 int UtcDaliAnimationKeyFrames04P(void)
8167 TestApplication application;
8169 KeyFrames keyFrames = KeyFrames::New();
8170 DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8172 keyFrames.Add(0.0f, Vector2(0.0f, 0.0f));
8173 keyFrames.Add(0.2f, Vector2(1.0f, 1.0f));
8174 keyFrames.Add(0.4f, Vector2(2.0f, 2.0f));
8175 keyFrames.Add(0.6f, Vector2(3.0f, 5.0f));
8176 keyFrames.Add(0.8f, Vector2(4.0f, 3.0f));
8177 keyFrames.Add(1.0f, Vector2(6.0f, 2.0f));
8179 DALI_TEST_EQUALS(keyFrames.GetType(), Property::VECTOR2, TEST_LOCATION);
8183 keyFrames.Add(0.7f, Vector3(1.0f, 1.0f, 1.0f));
8185 catch (Dali::DaliException& e)
8187 DALI_TEST_PRINT_ASSERT( e );
8188 DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8193 int UtcDaliAnimationKeyFrames05P(void)
8195 TestApplication application;
8197 KeyFrames keyFrames = KeyFrames::New();
8198 DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8200 keyFrames.Add(0.0f, Vector3(0.0f, 4.0f, 0.0f));
8201 keyFrames.Add(0.2f, Vector3(1.0f, 3.0f, 1.0f));
8202 keyFrames.Add(0.4f, Vector3(2.0f, 2.0f, 2.0f));
8203 keyFrames.Add(0.6f, Vector3(3.0f, 2.0f, 5.0f));
8204 keyFrames.Add(0.8f, Vector3(4.0f, 4.0f, 3.0f));
8205 keyFrames.Add(1.0f, Vector3(6.0f, 8.0f, 2.0f));
8207 DALI_TEST_EQUALS(keyFrames.GetType(), Property::VECTOR3, TEST_LOCATION);
8211 keyFrames.Add(0.7f, 1.0f);
8213 catch (Dali::DaliException& e)
8215 DALI_TEST_PRINT_ASSERT( e );
8216 DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8221 int UtcDaliAnimationKeyFrames06P(void)
8223 TestApplication application;
8225 KeyFrames keyFrames = KeyFrames::New();
8226 DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8228 keyFrames.Add(0.0f, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
8229 keyFrames.Add(0.2f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
8230 keyFrames.Add(0.4f, Vector4(2.0f, 2.0f, 2.0f, 2.0f));
8231 keyFrames.Add(0.6f, Vector4(3.0f, 5.0f, 3.0f, 5.0f));
8232 keyFrames.Add(0.8f, Vector4(4.0f, 3.0f, 4.0f, 3.0f));
8233 keyFrames.Add(1.0f, Vector4(6.0f, 2.0f, 6.0f, 2.0f));
8235 DALI_TEST_EQUALS(keyFrames.GetType(), Property::VECTOR4, TEST_LOCATION);
8239 keyFrames.Add(0.7f, Quaternion(Radian(1.717f), Vector3::XAXIS));
8241 catch (Dali::DaliException& e)
8243 DALI_TEST_PRINT_ASSERT( e );
8244 DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8249 int UtcDaliAnimationKeyFrames07P(void)
8251 TestApplication application;
8253 KeyFrames keyFrames = KeyFrames::New();
8254 DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8256 keyFrames.Add(0.0f, Quaternion(Radian(1.717f), Vector3::XAXIS));
8257 keyFrames.Add(0.2f, Quaternion(Radian(2.0f), Vector3::XAXIS));
8258 keyFrames.Add(0.4f, Quaternion(Radian(3.0f), Vector3::ZAXIS));
8259 keyFrames.Add(0.6f, Quaternion(Radian(4.0f), Vector3(1.0f, 1.0f, 1.0f)));
8260 keyFrames.Add(0.8f, AngleAxis(Degree(90), Vector3::XAXIS));
8261 keyFrames.Add(1.0f, Quaternion(Radian(3.0f), Vector3::YAXIS));
8263 DALI_TEST_EQUALS(keyFrames.GetType(), Property::ROTATION, TEST_LOCATION);
8267 keyFrames.Add(0.7f, 1.1f);
8269 catch (Dali::DaliException& e)
8271 DALI_TEST_PRINT_ASSERT( e );
8272 DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8277 int UtcDaliAnimationAnimateBetweenActorColorAlphaP(void)
8279 TestApplication application;
8281 float startValue(1.0f);
8282 Actor actor = Actor::New();
8283 actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
8284 Stage::GetCurrent().Add(actor);
8286 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8287 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8288 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8289 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8290 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8292 // Build the animation
8293 float durationSeconds(1.0f);
8294 Animation animation = Animation::New(durationSeconds);
8296 KeyFrames keyFrames = KeyFrames::New();
8297 keyFrames.Add(0.0f, 0.1f);
8298 keyFrames.Add(0.2f, 0.5f);
8299 keyFrames.Add(0.4f, 0.0f);
8300 keyFrames.Add(0.6f, 1.0f);
8301 keyFrames.Add(0.8f, 0.7f);
8302 keyFrames.Add(1.0f, 0.9f);
8304 animation.AnimateBetween( Property(actor, Actor::Property::COLOR_ALPHA), keyFrames );
8306 // Start the animation
8309 bool signalReceived(false);
8310 AnimationFinishCheck finishCheck(signalReceived);
8311 animation.FinishedSignal().Connect(&application, finishCheck);
8312 application.SendNotification();
8313 application.Render(0);
8314 application.SendNotification();
8315 finishCheck.CheckSignalNotReceived();
8316 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.1f, TEST_LOCATION );
8318 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
8319 application.SendNotification();
8320 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8321 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8322 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8323 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.3f, 0.01f, TEST_LOCATION );
8324 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.3f, 0.01f, TEST_LOCATION );
8326 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
8327 application.SendNotification();
8328 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8329 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8330 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8331 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.25f, 0.01f, TEST_LOCATION );
8332 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.25f, 0.01f, TEST_LOCATION );
8334 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 40% progress */);
8335 application.SendNotification();
8336 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8337 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8338 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8339 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.0f, 0.01f, TEST_LOCATION );
8340 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.0f, 0.01f, TEST_LOCATION );
8342 application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 80% progress */);
8343 application.SendNotification();
8344 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8345 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8346 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8347 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7f, 0.01f, TEST_LOCATION );
8348 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.7f, 0.01f, TEST_LOCATION );
8350 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 90% progress */);
8351 application.SendNotification();
8352 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8353 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8354 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8355 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.8f, 0.01f, TEST_LOCATION );
8356 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.8f, 0.01f, TEST_LOCATION );
8358 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)+1/* 100% progress */);
8359 application.SendNotification();
8360 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8361 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8362 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8363 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.9f, 0.01f, TEST_LOCATION );
8364 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.9f, 0.01f, TEST_LOCATION );
8366 // We did expect the animation to finish
8368 finishCheck.CheckSignalReceived();
8372 int UtcDaliAnimationAnimateBetweenActorColorAlphaCubicP(void)
8374 TestApplication application;
8376 float startValue(1.0f);
8377 Actor actor = Actor::New();
8378 actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
8379 Stage::GetCurrent().Add(actor);
8381 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8382 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8383 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8384 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8385 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8387 // Build the animation
8388 float durationSeconds(1.0f);
8389 Animation animation = Animation::New(durationSeconds);
8391 KeyFrames keyFrames = KeyFrames::New();
8392 keyFrames.Add(0.0f, 0.1f);
8393 keyFrames.Add(0.2f, 0.5f);
8394 keyFrames.Add(0.4f, 0.0f);
8395 keyFrames.Add(0.6f, 1.0f);
8396 keyFrames.Add(0.8f, 0.7f);
8397 keyFrames.Add(1.0f, 0.9f);
8399 animation.AnimateBetween( Property(actor, Actor::Property::COLOR_ALPHA), keyFrames, Animation::Cubic );
8401 // Start the animation
8404 bool signalReceived(false);
8405 AnimationFinishCheck finishCheck(signalReceived);
8406 animation.FinishedSignal().Connect(&application, finishCheck);
8407 application.SendNotification();
8408 application.Render(0);
8409 application.SendNotification();
8410 finishCheck.CheckSignalNotReceived();
8411 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.1f, TEST_LOCATION );
8413 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
8414 application.SendNotification();
8415 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8416 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8417 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8418 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.36f, 0.01f, TEST_LOCATION );
8419 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.36f, 0.01f, TEST_LOCATION );
8421 application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
8422 application.SendNotification();
8423 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8424 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8425 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8426 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.21f, 0.01f, TEST_LOCATION );
8427 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.21f, 0.01f, TEST_LOCATION );
8429 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 40% progress */);
8430 application.SendNotification();
8431 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8432 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8433 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8434 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.0f, 0.01f, TEST_LOCATION );
8435 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.0f, 0.01f, TEST_LOCATION );
8437 application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 80% progress */);
8438 application.SendNotification();
8439 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8440 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8441 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8442 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7f, 0.01f, TEST_LOCATION );
8443 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.7f, 0.01f, TEST_LOCATION );
8445 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 90% progress */);
8446 application.SendNotification();
8447 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8448 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8449 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8450 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.76f, 0.01f, TEST_LOCATION );
8451 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.76f, 0.01f, TEST_LOCATION );
8453 application.Render(static_cast<unsigned int>(durationSeconds*100.0f)+1/* 100% progress */);
8454 application.SendNotification();
8455 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8456 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8457 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8458 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.9f, 0.01f, TEST_LOCATION );
8459 DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.9f, 0.01f, TEST_LOCATION );
8461 // We did expect the animation to finish
8463 finishCheck.CheckSignalReceived();
8467 int UtcDaliAnimationAnimateBetweenActorColorP(void)
8469 TestApplication application;
8471 float startValue(1.0f);
8472 Actor actor = Actor::New();
8473 actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
8474 Stage::GetCurrent().Add(actor);
8476 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8477 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8478 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8479 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8480 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8482 // Build the animation
8483 float durationSeconds(1.0f);
8484 Animation animation = Animation::New(durationSeconds);
8486 KeyFrames keyFrames = KeyFrames::New();
8487 keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
8488 keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
8489 keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
8491 animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames );
8493 // Start the animation
8496 bool signalReceived(false);
8497 AnimationFinishCheck finishCheck(signalReceived);
8498 animation.FinishedSignal().Connect(&application, finishCheck);
8499 application.SendNotification();
8500 application.Render(0);
8501 application.SendNotification();
8502 finishCheck.CheckSignalNotReceived();
8503 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION );
8504 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
8505 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION );
8506 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
8508 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
8509 application.SendNotification();
8510 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.5f, 0.01f, TEST_LOCATION );
8511 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
8512 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.5f, 0.01f, TEST_LOCATION );
8513 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
8515 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
8516 application.SendNotification();
8517 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION );
8518 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
8519 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION );
8520 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
8522 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
8523 application.SendNotification();
8524 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.95f, 0.01f, TEST_LOCATION );
8525 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
8526 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.85f, 0.01f, TEST_LOCATION );
8527 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
8529 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
8530 application.SendNotification();
8531 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION );
8532 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
8533 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION );
8534 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
8536 // We did expect the animation to finish
8538 finishCheck.CheckSignalReceived();
8542 int UtcDaliAnimationAnimateBetweenActorColorCubicP(void)
8544 TestApplication application;
8546 float startValue(1.0f);
8547 Actor actor = Actor::New();
8548 actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
8549 Stage::GetCurrent().Add(actor);
8551 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8552 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8553 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8554 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8555 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8557 // Build the animation
8558 float durationSeconds(1.0f);
8559 Animation animation = Animation::New(durationSeconds);
8561 KeyFrames keyFrames = KeyFrames::New();
8562 keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
8563 keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
8564 keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
8566 animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, Animation::Cubic );
8568 // Start the animation
8571 bool signalReceived(false);
8572 AnimationFinishCheck finishCheck(signalReceived);
8573 animation.FinishedSignal().Connect(&application, finishCheck);
8574 application.SendNotification();
8575 application.Render(0);
8576 application.SendNotification();
8577 finishCheck.CheckSignalNotReceived();
8578 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION );
8579 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
8580 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION );
8581 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
8583 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
8584 application.SendNotification();
8585 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.55f, 0.01f, TEST_LOCATION );
8586 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION );
8587 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.506f, 0.01f, TEST_LOCATION );
8588 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION );
8590 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
8591 application.SendNotification();
8592 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION );
8593 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
8594 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION );
8595 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
8597 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
8598 application.SendNotification();
8599 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.99375f, 0.01f, TEST_LOCATION );
8600 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION );
8601 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.85625f, 0.01f, TEST_LOCATION );
8602 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION );
8604 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
8605 application.SendNotification();
8606 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION );
8607 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
8608 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION );
8609 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
8611 // We did expect the animation to finish
8613 finishCheck.CheckSignalReceived();
8617 int UtcDaliAnimationAnimateBetweenActorVisibleP(void)
8619 TestApplication application;
8621 Actor actor = Actor::New();
8622 AngleAxis aa(Degree(90), Vector3::XAXIS);
8623 actor.SetOrientation(aa.angle, aa.axis);
8624 Stage::GetCurrent().Add(actor);
8626 application.SendNotification();
8627 application.Render(0);
8629 DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION );
8631 // Build the animation
8632 float durationSeconds(1.0f);
8633 Animation animation = Animation::New(durationSeconds);
8635 KeyFrames keyFrames = KeyFrames::New();
8636 keyFrames.Add(0.0f, false);
8637 keyFrames.Add(0.2f, true);
8638 keyFrames.Add(0.4f, true);
8639 keyFrames.Add(0.8f, false);
8640 keyFrames.Add(1.0f, true);
8642 animation.AnimateBetween( Property(actor, Actor::Property::VISIBLE), keyFrames );
8644 // Start the animation
8647 bool signalReceived(false);
8648 AnimationFinishCheck finishCheck(signalReceived);
8649 animation.FinishedSignal().Connect(&application, finishCheck);
8650 application.SendNotification();
8651 application.SendNotification();
8652 application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
8653 application.SendNotification();
8654 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
8655 application.SendNotification();
8657 DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION);
8658 finishCheck.CheckSignalReceived();
8662 int UtcDaliAnimationAnimateBetweenActorVisibleCubicP(void)
8664 TestApplication application;
8666 Actor actor = Actor::New();
8667 AngleAxis aa(Degree(90), Vector3::XAXIS);
8668 actor.SetOrientation(aa.angle, aa.axis);
8669 Stage::GetCurrent().Add(actor);
8671 application.SendNotification();
8672 application.Render(0);
8674 DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION );
8676 // Build the animation
8677 float durationSeconds(1.0f);
8678 Animation animation = Animation::New(durationSeconds);
8680 KeyFrames keyFrames = KeyFrames::New();
8681 keyFrames.Add(0.0f, false);
8682 keyFrames.Add(0.2f, true);
8683 keyFrames.Add(0.4f, true);
8684 keyFrames.Add(0.8f, false);
8685 keyFrames.Add(1.0f, true);
8687 //Cubic interpolation for boolean values should be ignored
8688 animation.AnimateBetween( Property(actor, Actor::Property::VISIBLE), keyFrames, Animation::Cubic );
8690 // Start the animation
8693 bool signalReceived(false);
8694 AnimationFinishCheck finishCheck(signalReceived);
8695 animation.FinishedSignal().Connect(&application, finishCheck);
8696 application.SendNotification();
8697 application.SendNotification();
8698 application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
8699 application.SendNotification();
8700 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
8701 application.SendNotification();
8703 DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION);
8704 finishCheck.CheckSignalReceived();
8708 int UtcDaliAnimationAnimateBetweenActorOrientation01P(void)
8710 TestApplication application;
8712 Actor actor = Actor::New();
8713 AngleAxis aa(Degree(90), Vector3::XAXIS);
8714 actor.SetOrientation(aa.angle, aa.axis);
8715 Stage::GetCurrent().Add(actor);
8717 application.SendNotification();
8718 application.Render(0);
8719 Quaternion start(Radian(aa.angle), aa.axis);
8720 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), start, 0.001f, TEST_LOCATION );
8722 // Build the animation
8723 float durationSeconds(1.0f);
8724 Animation animation = Animation::New(durationSeconds);
8726 KeyFrames keyFrames = KeyFrames::New();
8727 keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::ZAXIS));
8729 animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames );
8731 // Start the animation
8734 bool signalReceived(false);
8735 AnimationFinishCheck finishCheck(signalReceived);
8736 animation.FinishedSignal().Connect(&application, finishCheck);
8737 application.SendNotification();
8738 application.SendNotification();
8739 application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
8740 application.SendNotification();
8741 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
8742 application.SendNotification();
8744 Quaternion check( Radian(Degree(60)), Vector3::ZAXIS );
8746 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8747 finishCheck.CheckSignalReceived();
8751 int UtcDaliAnimationAnimateBetweenActorOrientation02P(void)
8753 TestApplication application;
8755 Actor actor = Actor::New();
8756 AngleAxis aa(Degree(90), Vector3::XAXIS);
8757 actor.SetOrientation(aa.angle, aa.axis);
8758 application.SendNotification();
8759 application.Render(0);
8760 Stage::GetCurrent().Add(actor);
8762 Quaternion start(Radian(aa.angle), aa.axis);
8763 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), start, 0.001f, TEST_LOCATION );
8765 // Build the animation
8766 float durationSeconds(1.0f);
8767 Animation animation = Animation::New(durationSeconds);
8769 KeyFrames keyFrames = KeyFrames::New();
8770 keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::XAXIS));
8771 keyFrames.Add(0.5f, AngleAxis(Degree(120), Vector3::XAXIS));
8772 keyFrames.Add(1.0f, AngleAxis(Degree(120), Vector3::YAXIS));
8774 animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames );
8776 // Start the animation
8779 bool signalReceived(false);
8780 AnimationFinishCheck finishCheck(signalReceived);
8781 animation.FinishedSignal().Connect(&application, finishCheck);
8782 application.SendNotification();
8783 application.Render(0);
8784 application.SendNotification();
8785 finishCheck.CheckSignalNotReceived();
8787 Quaternion check(Radian(Degree(60)), Vector3::XAXIS);
8788 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8790 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
8791 application.SendNotification();
8792 check = Quaternion( Radian(Degree(90)), Vector3::XAXIS );
8793 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8795 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
8796 application.SendNotification();
8797 check = Quaternion( Radian(Degree(120)), Vector3::XAXIS );
8798 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8800 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
8801 application.SendNotification();
8802 check = Quaternion( Radian(Degree(101.5)), Vector3(0.5f, 0.5f, 0.0f) );
8803 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8805 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
8806 application.SendNotification();
8807 check = Quaternion( Radian(Degree(120)), Vector3::YAXIS );
8808 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8810 // We did expect the animation to finish
8812 finishCheck.CheckSignalReceived();
8816 int UtcDaliAnimationAnimateBetweenActorOrientation01CubicP(void)
8818 TestApplication application;
8820 Actor actor = Actor::New();
8821 AngleAxis aa(Degree(90), Vector3::XAXIS);
8822 actor.SetOrientation(aa.angle, aa.axis);
8823 Stage::GetCurrent().Add(actor);
8825 application.SendNotification();
8826 application.Render(0);
8827 Quaternion start(Radian(aa.angle), aa.axis);
8828 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), start, 0.001f, TEST_LOCATION );
8830 // Build the animation
8831 float durationSeconds(1.0f);
8832 Animation animation = Animation::New(durationSeconds);
8834 KeyFrames keyFrames = KeyFrames::New();
8835 keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::ZAXIS));
8837 //Cubic interpolation should be ignored for quaternions
8838 animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames, Animation::Cubic );
8840 // Start the animation
8843 bool signalReceived(false);
8844 AnimationFinishCheck finishCheck(signalReceived);
8845 animation.FinishedSignal().Connect(&application, finishCheck);
8846 application.SendNotification();
8847 application.SendNotification();
8848 application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
8849 application.SendNotification();
8850 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
8851 application.SendNotification();
8853 Quaternion check( Radian(Degree(60)), Vector3::ZAXIS );
8855 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8856 finishCheck.CheckSignalReceived();
8860 int UtcDaliAnimationAnimateBetweenActorOrientation02CubicP(void)
8862 TestApplication application;
8864 Actor actor = Actor::New();
8865 AngleAxis aa(Degree(90), Vector3::XAXIS);
8866 actor.SetOrientation(aa.angle, aa.axis);
8867 application.SendNotification();
8868 application.Render(0);
8869 Stage::GetCurrent().Add(actor);
8871 Quaternion start(Radian(aa.angle), aa.axis);
8872 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), start, 0.001f, TEST_LOCATION );
8874 // Build the animation
8875 float durationSeconds(1.0f);
8876 Animation animation = Animation::New(durationSeconds);
8878 KeyFrames keyFrames = KeyFrames::New();
8879 keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::XAXIS));
8880 keyFrames.Add(0.5f, AngleAxis(Degree(120), Vector3::XAXIS));
8881 keyFrames.Add(1.0f, AngleAxis(Degree(120), Vector3::YAXIS));
8883 //Cubic interpolation should be ignored for quaternions
8884 animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames, Animation::Cubic );
8886 // Start the animation
8889 bool signalReceived(false);
8890 AnimationFinishCheck finishCheck(signalReceived);
8891 animation.FinishedSignal().Connect(&application, finishCheck);
8892 application.SendNotification();
8893 application.Render(0);
8894 application.SendNotification();
8895 finishCheck.CheckSignalNotReceived();
8897 Quaternion check(Radian(Degree(60)), Vector3::XAXIS);
8898 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8900 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
8901 application.SendNotification();
8902 check = Quaternion( Radian(Degree(90)), Vector3::XAXIS );
8903 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8905 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
8906 application.SendNotification();
8907 check = Quaternion( Radian(Degree(120)), Vector3::XAXIS );
8908 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8910 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
8911 application.SendNotification();
8912 check = Quaternion( Radian(Degree(101.5)), Vector3(0.5f, 0.5f, 0.0f ) );
8913 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8915 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
8916 application.SendNotification();
8917 check = Quaternion( Radian(Degree(120)), Vector3::YAXIS );
8918 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8920 // We did expect the animation to finish
8922 finishCheck.CheckSignalReceived();
8926 int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionP(void)
8928 TestApplication application;
8930 float startValue(1.0f);
8931 Actor actor = Actor::New();
8932 actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
8933 Stage::GetCurrent().Add(actor);
8935 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8936 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
8937 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8938 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
8939 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8941 // Build the animation
8942 float durationSeconds(1.0f);
8943 Animation animation = Animation::New(durationSeconds);
8945 KeyFrames keyFrames = KeyFrames::New();
8946 keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
8947 keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
8948 keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
8950 animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR );
8952 // Start the animation
8955 bool signalReceived(false);
8956 AnimationFinishCheck finishCheck(signalReceived);
8957 animation.FinishedSignal().Connect(&application, finishCheck);
8958 application.SendNotification();
8959 application.Render(0);
8960 application.SendNotification();
8961 finishCheck.CheckSignalNotReceived();
8962 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION );
8963 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
8964 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION );
8965 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
8967 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
8968 application.SendNotification();
8969 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.5f, 0.01f, TEST_LOCATION );
8970 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
8971 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.5f, 0.01f, TEST_LOCATION );
8972 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
8974 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
8975 application.SendNotification();
8976 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION );
8977 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
8978 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION );
8979 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
8981 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
8982 application.SendNotification();
8983 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.95f, 0.01f, TEST_LOCATION );
8984 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
8985 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.85f, 0.01f, TEST_LOCATION );
8986 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
8988 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
8989 application.SendNotification();
8990 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION );
8991 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
8992 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION );
8993 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
8995 // We did expect the animation to finish
8997 finishCheck.CheckSignalReceived();
9001 int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionCubicP(void)
9003 TestApplication application;
9005 float startValue(1.0f);
9006 Actor actor = Actor::New();
9007 actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
9008 Stage::GetCurrent().Add(actor);
9010 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
9011 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
9012 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
9013 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
9014 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
9016 // Build the animation
9017 float durationSeconds(1.0f);
9018 Animation animation = Animation::New(durationSeconds);
9020 KeyFrames keyFrames = KeyFrames::New();
9021 keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
9022 keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
9023 keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
9025 animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, Animation::Cubic );
9027 // Start the animation
9030 bool signalReceived(false);
9031 AnimationFinishCheck finishCheck(signalReceived);
9032 animation.FinishedSignal().Connect(&application, finishCheck);
9033 application.SendNotification();
9034 application.Render(0);
9035 application.SendNotification();
9036 finishCheck.CheckSignalNotReceived();
9037 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION );
9038 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
9039 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION );
9040 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
9042 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
9043 application.SendNotification();
9044 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.55f, 0.01f, TEST_LOCATION );
9045 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION );
9046 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.506f, 0.01f, TEST_LOCATION );
9047 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION );
9049 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
9050 application.SendNotification();
9051 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION );
9052 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
9053 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION );
9054 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
9056 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
9057 application.SendNotification();
9058 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.99375f, 0.01f, TEST_LOCATION );
9059 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION );
9060 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.85625f, 0.01f, TEST_LOCATION );
9061 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION );
9063 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
9064 application.SendNotification();
9065 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION );
9066 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
9067 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION );
9068 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
9070 // We did expect the animation to finish
9072 finishCheck.CheckSignalReceived();
9076 int UtcDaliAnimationAnimateBetweenActorColorTimePeriodP(void)
9078 TestApplication application;
9080 float startValue(1.0f);
9081 Actor actor = Actor::New();
9082 actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
9083 Stage::GetCurrent().Add(actor);
9085 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
9086 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
9087 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
9088 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
9089 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
9091 // Build the animation
9092 float durationSeconds(1.0f);
9094 Animation animation = Animation::New(durationSeconds);
9096 KeyFrames keyFrames = KeyFrames::New();
9097 keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
9098 keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
9099 keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
9101 animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, TimePeriod( delay, durationSeconds - delay ) );
9103 // Start the animation
9106 bool signalReceived(false);
9107 AnimationFinishCheck finishCheck(signalReceived);
9108 animation.FinishedSignal().Connect(&application, finishCheck);
9109 application.SendNotification();
9111 application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
9112 application.SendNotification();
9113 finishCheck.CheckSignalNotReceived();
9114 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION );
9115 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
9116 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION );
9117 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
9119 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
9120 application.SendNotification();
9121 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.5f, 0.01f, TEST_LOCATION );
9122 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
9123 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.5f, 0.01f, TEST_LOCATION );
9124 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
9126 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
9127 application.SendNotification();
9128 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION );
9129 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
9130 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION );
9131 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
9133 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
9134 application.SendNotification();
9135 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.95f, 0.01f, TEST_LOCATION );
9136 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
9137 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.85f, 0.01f, TEST_LOCATION );
9138 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
9140 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
9141 application.SendNotification();
9142 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION );
9143 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
9144 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION );
9145 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
9147 // We did expect the animation to finish
9149 finishCheck.CheckSignalReceived();
9153 int UtcDaliAnimationAnimateBetweenActorColorTimePeriodCubicP(void)
9155 TestApplication application;
9157 float startValue(1.0f);
9158 Actor actor = Actor::New();
9159 actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
9160 Stage::GetCurrent().Add(actor);
9162 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
9163 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
9164 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
9165 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
9166 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
9168 // Build the animation
9169 float durationSeconds(1.0f);
9171 Animation animation = Animation::New(durationSeconds);
9173 KeyFrames keyFrames = KeyFrames::New();
9174 keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
9175 keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
9176 keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
9178 animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, TimePeriod( delay, durationSeconds - delay ), Animation::Cubic );
9180 // Start the animation
9183 bool signalReceived(false);
9184 AnimationFinishCheck finishCheck(signalReceived);
9185 animation.FinishedSignal().Connect(&application, finishCheck);
9186 application.SendNotification();
9188 application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
9189 application.SendNotification();
9190 finishCheck.CheckSignalNotReceived();
9191 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION );
9192 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
9193 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION );
9194 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
9196 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
9197 application.SendNotification();
9198 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.55f, 0.01f, TEST_LOCATION );
9199 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION );
9200 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.506f, 0.01f, TEST_LOCATION );
9201 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION );
9203 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
9204 application.SendNotification();
9205 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION );
9206 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
9207 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION );
9208 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
9210 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
9211 application.SendNotification();
9212 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.99375f, 0.01f, TEST_LOCATION );
9213 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION );
9214 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.85625f, 0.01f, TEST_LOCATION );
9215 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION );
9217 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
9218 application.SendNotification();
9219 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION );
9220 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
9221 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION );
9222 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
9224 // We did expect the animation to finish
9226 finishCheck.CheckSignalReceived();
9230 int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionTimePeriodP(void)
9232 TestApplication application;
9234 float startValue(1.0f);
9236 Actor actor = Actor::New();
9237 actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
9238 Stage::GetCurrent().Add(actor);
9240 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
9241 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
9242 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
9243 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
9244 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
9246 // Build the animation
9247 float durationSeconds(1.0f);
9248 Animation animation = Animation::New(durationSeconds);
9250 KeyFrames keyFrames = KeyFrames::New();
9251 keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
9252 keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
9253 keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
9255 animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
9257 // Start the animation
9260 bool signalReceived(false);
9261 AnimationFinishCheck finishCheck(signalReceived);
9262 animation.FinishedSignal().Connect(&application, finishCheck);
9263 application.SendNotification();
9265 application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
9266 application.SendNotification();
9267 finishCheck.CheckSignalNotReceived();
9268 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION );
9269 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
9270 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION );
9271 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
9273 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
9274 application.SendNotification();
9275 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.5f, 0.01f, TEST_LOCATION );
9276 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
9277 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.5f, 0.01f, TEST_LOCATION );
9278 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
9280 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
9281 application.SendNotification();
9282 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION );
9283 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
9284 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION );
9285 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
9287 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
9288 application.SendNotification();
9289 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.95f, 0.01f, TEST_LOCATION );
9290 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
9291 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.85f, 0.01f, TEST_LOCATION );
9292 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
9294 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
9295 application.SendNotification();
9296 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION );
9297 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
9298 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION );
9299 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
9301 // We did expect the animation to finish
9303 finishCheck.CheckSignalReceived();
9307 int UtcDaliAnimationAnimateBetweenActorColorCubicWithDelayP(void)
9309 TestApplication application;
9311 float startValue(1.0f);
9312 Actor actor = Actor::New();
9313 actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
9314 Stage::GetCurrent().Add(actor);
9316 DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
9317 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
9318 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
9319 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
9320 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
9322 // Build the animation
9323 float durationSeconds(1.0f);
9325 Animation animation = Animation::New(durationSeconds);
9327 KeyFrames keyFrames = KeyFrames::New();
9328 keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
9329 keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
9330 keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
9332 animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ), Animation::Cubic );
9334 // Start the animation
9337 bool signalReceived(false);
9338 AnimationFinishCheck finishCheck(signalReceived);
9339 animation.FinishedSignal().Connect(&application, finishCheck);
9340 application.SendNotification();
9342 application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
9343 application.SendNotification();
9344 finishCheck.CheckSignalNotReceived();
9345 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION );
9346 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
9347 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION );
9348 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
9350 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
9351 application.SendNotification();
9352 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.55f, 0.01f, TEST_LOCATION );
9353 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION );
9354 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.506f, 0.01f, TEST_LOCATION );
9355 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION );
9357 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
9358 application.SendNotification();
9359 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION );
9360 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
9361 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION );
9362 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
9364 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
9365 application.SendNotification();
9366 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.99375f, 0.01f, TEST_LOCATION );
9367 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION );
9368 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 0.85625f, 0.01f, TEST_LOCATION );
9369 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION );
9371 application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
9372 application.SendNotification();
9373 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION );
9374 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
9375 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION );
9376 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
9378 // We did expect the animation to finish
9380 finishCheck.CheckSignalReceived();
9384 int UtcDaliAnimationAnimateP(void)
9386 TestApplication application;
9388 Actor actor = Actor::New();
9389 Stage::GetCurrent().Add(actor);
9392 Vector3 position0( 30.0, 80.0, 0.0);
9393 Vector3 position1( 70.0, 120.0, 0.0);
9394 Vector3 position2( 100.0, 100.0, 0.0);
9396 Dali::Path path = Dali::Path::New();
9397 path.AddPoint(position0);
9398 path.AddPoint(position1);
9399 path.AddPoint(position2);
9401 //Control points for first segment
9402 path.AddControlPoint( Vector3( 39.0, 90.0, 0.0) );
9403 path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
9405 //Control points for second segment
9406 path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
9407 path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
9409 // Build the animation
9410 float durationSeconds( 1.0f );
9411 Animation animation = Animation::New(durationSeconds);
9412 animation.Animate(actor, path, Vector3::XAXIS);
9414 // Start the animation
9417 bool signalReceived(false);
9418 AnimationFinishCheck finishCheck(signalReceived);
9419 animation.FinishedSignal().Connect(&application, finishCheck);
9420 application.SendNotification();
9421 application.Render(0);
9422 application.SendNotification();
9423 finishCheck.CheckSignalNotReceived();
9424 Vector3 position, tangent;
9425 Quaternion rotation;
9426 path.Sample( 0.0f, position, tangent );
9427 rotation = Quaternion( Vector3::XAXIS, tangent );
9428 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9429 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9431 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
9432 application.SendNotification();
9433 path.Sample( 0.25f, position, tangent );
9434 rotation = Quaternion( Vector3::XAXIS, tangent );
9435 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9436 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9438 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
9439 application.SendNotification();
9440 path.Sample( 0.5f, position, tangent );
9441 rotation = Quaternion( Vector3::XAXIS, tangent );
9442 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9443 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9445 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
9446 application.SendNotification();
9447 path.Sample( 0.75f, position, tangent );
9448 rotation = Quaternion( Vector3::XAXIS, tangent );
9449 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9450 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9452 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
9453 application.SendNotification();
9454 path.Sample( 1.0f, position, tangent );
9455 rotation = Quaternion( Vector3::XAXIS, tangent );
9456 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9457 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9459 finishCheck.CheckSignalReceived();
9463 int UtcDaliAnimationAnimateAlphaFunctionP(void)
9465 TestApplication application;
9467 Actor actor = Actor::New();
9468 Stage::GetCurrent().Add(actor);
9471 Vector3 position0( 30.0, 80.0, 0.0);
9472 Vector3 position1( 70.0, 120.0, 0.0);
9473 Vector3 position2( 100.0, 100.0, 0.0);
9475 Dali::Path path = Dali::Path::New();
9476 path.AddPoint(position0);
9477 path.AddPoint(position1);
9478 path.AddPoint(position2);
9480 //Control points for first segment
9481 path.AddControlPoint( Vector3( 39.0, 90.0, 0.0) );
9482 path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
9484 //Control points for second segment
9485 path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
9486 path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
9488 // Build the animation
9489 float durationSeconds( 1.0f );
9490 Animation animation = Animation::New(durationSeconds);
9491 animation.Animate(actor, path, Vector3::XAXIS, AlphaFunction::LINEAR);
9493 // Start the animation
9496 bool signalReceived(false);
9497 AnimationFinishCheck finishCheck(signalReceived);
9498 animation.FinishedSignal().Connect(&application, finishCheck);
9499 application.SendNotification();
9500 application.Render(0);
9501 application.SendNotification();
9502 finishCheck.CheckSignalNotReceived();
9503 Vector3 position, tangent;
9504 Quaternion rotation;
9505 path.Sample( 0.0f, position, tangent );
9506 rotation = Quaternion( Vector3::XAXIS, tangent );
9507 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9508 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9510 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
9511 application.SendNotification();
9512 path.Sample( 0.25f, position, tangent );
9513 rotation = Quaternion( Vector3::XAXIS, tangent );
9514 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9515 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9517 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
9518 application.SendNotification();
9519 path.Sample( 0.5f, position, tangent );
9520 rotation = Quaternion( Vector3::XAXIS, tangent );
9521 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9522 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9524 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
9525 application.SendNotification();
9526 path.Sample( 0.75f, position, tangent );
9527 rotation = Quaternion( Vector3::XAXIS, tangent );
9528 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9529 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9531 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
9532 application.SendNotification();
9533 path.Sample( 1.0f, position, tangent );
9534 rotation = Quaternion( Vector3::XAXIS, tangent );
9535 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9536 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9538 finishCheck.CheckSignalReceived();
9542 int UtcDaliAnimationAnimateTimePeriodP(void)
9544 TestApplication application;
9546 Actor actor = Actor::New();
9547 Stage::GetCurrent().Add(actor);
9550 Vector3 position0( 30.0, 80.0, 0.0);
9551 Vector3 position1( 70.0, 120.0, 0.0);
9552 Vector3 position2( 100.0, 100.0, 0.0);
9554 Dali::Path path = Dali::Path::New();
9555 path.AddPoint(position0);
9556 path.AddPoint(position1);
9557 path.AddPoint(position2);
9559 //Control points for first segment
9560 path.AddControlPoint( Vector3( 39.0, 90.0, 0.0) );
9561 path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
9563 //Control points for second segment
9564 path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
9565 path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
9567 // Build the animation
9568 float durationSeconds( 1.0f );
9569 Animation animation = Animation::New(durationSeconds);
9570 animation.Animate(actor, path, Vector3::XAXIS, TimePeriod(0.0f, 1.0f));
9572 // Start the animation
9575 bool signalReceived(false);
9576 AnimationFinishCheck finishCheck(signalReceived);
9577 animation.FinishedSignal().Connect(&application, finishCheck);
9578 application.SendNotification();
9579 application.Render(0);
9580 application.SendNotification();
9581 finishCheck.CheckSignalNotReceived();
9582 Vector3 position, tangent;
9583 Quaternion rotation;
9584 path.Sample( 0.0f, position, tangent );
9585 rotation = Quaternion( Vector3::XAXIS, tangent );
9586 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9587 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9589 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
9590 application.SendNotification();
9591 path.Sample( 0.25f, position, tangent );
9592 rotation = Quaternion( Vector3::XAXIS, tangent );
9593 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9594 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9596 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
9597 application.SendNotification();
9598 path.Sample( 0.5f, position, tangent );
9599 rotation = Quaternion( Vector3::XAXIS, tangent );
9600 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9601 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9603 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
9604 application.SendNotification();
9605 path.Sample( 0.75f, position, tangent );
9606 rotation = Quaternion( Vector3::XAXIS, tangent );
9607 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9608 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9610 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
9611 application.SendNotification();
9612 path.Sample( 1.0f, position, tangent );
9613 rotation = Quaternion( Vector3::XAXIS, tangent );
9614 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9615 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9617 finishCheck.CheckSignalReceived();
9621 int UtcDaliAnimationAnimateAlphaFunctionTimePeriodP(void)
9623 TestApplication application;
9625 Actor actor = Actor::New();
9626 Stage::GetCurrent().Add(actor);
9629 Vector3 position0( 30.0, 80.0, 0.0);
9630 Vector3 position1( 70.0, 120.0, 0.0);
9631 Vector3 position2( 100.0, 100.0, 0.0);
9633 Dali::Path path = Dali::Path::New();
9634 path.AddPoint(position0);
9635 path.AddPoint(position1);
9636 path.AddPoint(position2);
9638 //Control points for first segment
9639 path.AddControlPoint( Vector3( 39.0, 90.0, 0.0) );
9640 path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
9642 //Control points for second segment
9643 path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
9644 path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
9646 // Build the animation
9647 float durationSeconds( 1.0f );
9648 Animation animation = Animation::New(durationSeconds);
9649 animation.Animate(actor, path, Vector3::XAXIS, AlphaFunction::LINEAR, TimePeriod(0.0f, 1.0f));
9651 // Start the animation
9654 bool signalReceived(false);
9655 AnimationFinishCheck finishCheck(signalReceived);
9656 animation.FinishedSignal().Connect(&application, finishCheck);
9657 application.SendNotification();
9658 application.Render(0);
9659 application.SendNotification();
9660 finishCheck.CheckSignalNotReceived();
9661 Vector3 position, tangent;
9662 Quaternion rotation;
9663 path.Sample( 0.0f, position, tangent );
9664 rotation = Quaternion( Vector3::XAXIS, tangent );
9665 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9666 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9668 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
9669 application.SendNotification();
9670 path.Sample( 0.25f, position, tangent );
9671 rotation = Quaternion( Vector3::XAXIS, tangent );
9672 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9673 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9675 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
9676 application.SendNotification();
9677 path.Sample( 0.5f, position, tangent );
9678 rotation = Quaternion( Vector3::XAXIS, tangent );
9679 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9680 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9682 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
9683 application.SendNotification();
9684 path.Sample( 0.75f, position, tangent );
9685 rotation = Quaternion( Vector3::XAXIS, tangent );
9686 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9687 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9689 application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
9690 application.SendNotification();
9691 path.Sample( 1.0f, position, tangent );
9692 rotation = Quaternion( Vector3::XAXIS, tangent );
9693 DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9694 DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9696 finishCheck.CheckSignalReceived();
9700 int UtcDaliAnimationShowP(void)
9702 TestApplication application;
9704 Actor actor = Actor::New();
9705 actor.SetVisible(false);
9706 application.SendNotification();
9707 application.Render(0);
9708 DALI_TEST_CHECK( !actor.IsVisible() );
9709 Stage::GetCurrent().Add(actor);
9711 // Start the animation
9712 float durationSeconds(10.0f);
9713 Animation animation = Animation::New(durationSeconds);
9714 animation.Show(actor, durationSeconds*0.5f);
9717 bool signalReceived(false);
9718 AnimationFinishCheck finishCheck(signalReceived);
9719 animation.FinishedSignal().Connect(&application, finishCheck);
9721 application.SendNotification();
9722 application.Render(static_cast<unsigned int>(durationSeconds*490.0f));
9724 // We didn't expect the animation to finish yet
9725 application.SendNotification();
9726 finishCheck.CheckSignalNotReceived();
9727 DALI_TEST_CHECK( !actor.IsVisible() );
9729 application.SendNotification();
9730 application.Render(static_cast<unsigned int>(durationSeconds*10.0f)/*Should be shown now*/);
9732 // We didn't expect the animation to finish yet
9733 application.SendNotification();
9734 finishCheck.CheckSignalNotReceived();
9735 DALI_TEST_CHECK( actor.IsVisible() );
9737 application.SendNotification();
9738 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
9740 // We did expect the animation to finish
9741 application.SendNotification();
9742 finishCheck.CheckSignalReceived();
9743 DALI_TEST_CHECK( actor.IsVisible() );
9747 int UtcDaliAnimationHideP(void)
9749 TestApplication application;
9751 Actor actor = Actor::New();
9752 DALI_TEST_CHECK( actor.IsVisible() );
9753 Stage::GetCurrent().Add(actor);
9755 // Start the animation
9756 float durationSeconds(10.0f);
9757 Animation animation = Animation::New(durationSeconds);
9758 animation.Hide(actor, durationSeconds*0.5f);
9761 bool signalReceived(false);
9762 AnimationFinishCheck finishCheck(signalReceived);
9763 animation.FinishedSignal().Connect(&application, finishCheck);
9765 application.SendNotification();
9766 application.Render(static_cast<unsigned int>(durationSeconds*490.0f));
9768 // We didn't expect the animation to finish yet
9769 application.SendNotification();
9770 finishCheck.CheckSignalNotReceived();
9771 DALI_TEST_CHECK( actor.IsVisible() );
9773 application.SendNotification();
9774 application.Render(static_cast<unsigned int>(durationSeconds*10.0f)/*Should be hidden now*/);
9776 // We didn't expect the animation to finish yet
9777 application.SendNotification();
9778 finishCheck.CheckSignalNotReceived();
9779 DALI_TEST_CHECK( !actor.IsVisible() );
9781 application.SendNotification();
9782 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
9784 // We did expect the animation to finish
9785 application.SendNotification();
9786 finishCheck.CheckSignalReceived();
9787 DALI_TEST_CHECK( !actor.IsVisible() );
9791 int UtcDaliAnimationShowHideAtEndP(void)
9793 // Test that show/hide delay can be the same as animation duration
9794 // i.e. to show/hide at the end of the animation
9796 TestApplication application;
9798 Actor actor = Actor::New();
9799 DALI_TEST_CHECK( actor.IsVisible() );
9800 Stage::GetCurrent().Add(actor);
9802 // Start Hide animation
9803 float durationSeconds(10.0f);
9804 Animation animation = Animation::New(durationSeconds);
9805 animation.Hide(actor, durationSeconds/*Hide at end*/);
9808 bool signalReceived(false);
9809 AnimationFinishCheck finishCheck(signalReceived);
9810 animation.FinishedSignal().Connect(&application, finishCheck);
9812 application.SendNotification();
9813 application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
9815 // We did expect the animation to finish
9816 application.SendNotification();
9817 finishCheck.CheckSignalReceived();
9818 DALI_TEST_CHECK( !actor.IsVisible() );
9820 // Start Show animation
9821 animation = Animation::New(durationSeconds);
9822 animation.Show(actor, durationSeconds/*Show at end*/);
9823 animation.FinishedSignal().Connect(&application, finishCheck);
9826 application.SendNotification();
9827 application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
9829 // We did expect the animation to finish
9830 application.SendNotification();
9831 finishCheck.CheckSignalReceived();
9832 DALI_TEST_CHECK( actor.IsVisible() );
9836 int UtcDaliKeyFramesCreateDestroyP(void)
9838 tet_infoline("Testing Dali::Animation::UtcDaliKeyFramesCreateDestroy()");
9840 KeyFrames* keyFrames = new KeyFrames;
9842 DALI_TEST_CHECK( true );
9846 int UtcDaliKeyFramesDownCastP(void)
9848 TestApplication application;
9849 tet_infoline("Testing Dali::Animation::KeyFramesDownCast()");
9851 KeyFrames keyFrames = KeyFrames::New();
9852 BaseHandle object(keyFrames);
9854 KeyFrames keyFrames2 = KeyFrames::DownCast(object);
9855 DALI_TEST_CHECK(keyFrames2);
9857 KeyFrames keyFrames3 = DownCast< KeyFrames >(object);
9858 DALI_TEST_CHECK(keyFrames3);
9860 BaseHandle unInitializedObject;
9861 KeyFrames keyFrames4 = KeyFrames::DownCast(unInitializedObject);
9862 DALI_TEST_CHECK(!keyFrames4);
9864 KeyFrames keyFrames5 = DownCast< KeyFrames >(unInitializedObject);
9865 DALI_TEST_CHECK(!keyFrames5);
9869 int UtcDaliAnimationCreateDestroyP(void)
9871 TestApplication application;
9872 Animation* animation = new Animation;
9873 DALI_TEST_CHECK( animation );
9878 struct UpdateManagerTestConstraint
9880 UpdateManagerTestConstraint(TestApplication& application)
9881 : mApplication(application)
9885 void operator()( Vector3& current, const PropertyInputContainer& /* inputs */)
9887 mApplication.SendNotification(); // Process events
9890 TestApplication& mApplication;
9893 int UtcDaliAnimationUpdateManagerP(void)
9895 TestApplication application;
9897 Actor actor = Actor::New();
9898 Stage::GetCurrent().Add( actor );
9900 // Build the animation
9901 Animation animation = Animation::New( 0.0f );
9903 bool signalReceived = false;
9904 AnimationFinishCheck finishCheck( signalReceived );
9905 animation.FinishedSignal().Connect( &application, finishCheck );
9907 Vector3 startValue(1.0f, 1.0f, 1.0f);
9908 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
9909 Constraint constraint = Constraint::New<Vector3>( actor, index, UpdateManagerTestConstraint( application ) );
9912 // Apply animation to actor
9913 animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 100.f, 90.f, 80.f ), AlphaFunction::LINEAR );
9914 animation.AnimateTo( Property(actor, DevelActor::Property::OPACITY), 0.3f, AlphaFunction::LINEAR );
9918 application.SendNotification();
9919 application.UpdateOnly( 16 );
9921 finishCheck.CheckSignalNotReceived();
9923 application.SendNotification(); // Process events
9925 finishCheck.CheckSignalReceived();
9930 int UtcDaliAnimationSignalOrderP(void)
9932 TestApplication application;
9934 Actor actor = Actor::New();
9935 Stage::GetCurrent().Add( actor );
9937 // Build the animations
9938 Animation animation1 = Animation::New( 0.0f ); // finishes first frame
9939 Animation animation2 = Animation::New( 0.02f ); // finishes in 20 ms
9941 bool signal1Received = false;
9942 animation1.FinishedSignal().Connect( &application, AnimationFinishCheck( signal1Received ) );
9944 bool signal2Received = false;
9945 animation2.FinishedSignal().Connect( &application, AnimationFinishCheck( signal2Received ) );
9947 // Apply animations to actor
9948 animation1.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 3.0f, 2.0f, 1.0f ), AlphaFunction::LINEAR );
9950 animation2.AnimateTo( Property(actor, Actor::Property::SIZE ), Vector3( 10.0f, 20.0f, 30.0f ), AlphaFunction::LINEAR );
9953 DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
9954 DALI_TEST_EQUALS( signal2Received, false, TEST_LOCATION );
9956 application.SendNotification();
9957 application.UpdateOnly( 10 ); // 10ms progress
9959 // no notifications yet
9960 DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
9961 DALI_TEST_EQUALS( signal2Received, false, TEST_LOCATION );
9963 application.SendNotification();
9966 DALI_TEST_EQUALS( signal1Received, true, TEST_LOCATION );
9967 DALI_TEST_EQUALS( signal2Received, false, TEST_LOCATION );
9968 signal1Received = false;
9970 // 1st animation is complete now, do another update with no ProcessEvents in between
9971 application.UpdateOnly( 20 ); // 20ms progress
9974 application.SendNotification();
9976 // 2nd should complete now
9977 DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
9978 DALI_TEST_EQUALS( signal2Received, true, TEST_LOCATION );
9983 int UtcDaliAnimationExtendDurationP(void)
9985 TestApplication application;
9987 Actor actor = Actor::New();
9989 // Register a float property
9990 float startValue(10.0f);
9991 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
9992 Stage::GetCurrent().Add(actor);
9993 DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
9994 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
9996 // Build the animation
9997 float initialDurationSeconds(1.0f);
9998 float animatorDelay = 5.0f;
9999 float animatorDurationSeconds(5.0f);
10000 float extendedDurationSeconds(animatorDelay+animatorDurationSeconds);
10001 Animation animation = Animation::New(initialDurationSeconds);
10002 float targetValue(30.0f);
10003 float relativeValue(targetValue - startValue);
10005 animation.AnimateTo(Property(actor, index),
10007 TimePeriod(animatorDelay, animatorDurationSeconds));
10009 // The duration should have been extended
10010 DALI_TEST_EQUALS( animation.GetDuration(), extendedDurationSeconds, TEST_LOCATION );
10012 // Start the animation
10015 bool signalReceived(false);
10016 AnimationFinishCheck finishCheck(signalReceived);
10017 animation.FinishedSignal().Connect(&application, finishCheck);
10019 application.SendNotification();
10020 application.Render(static_cast<unsigned int>(extendedDurationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
10022 // We didn't expect the animation to finish yet
10023 application.SendNotification();
10024 finishCheck.CheckSignalNotReceived();
10025 DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
10027 application.SendNotification();
10028 application.Render(static_cast<unsigned int>(extendedDurationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
10030 // We didn't expect the animation to finish yet
10031 application.SendNotification();
10032 finishCheck.CheckSignalNotReceived();
10033 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
10035 application.SendNotification();
10036 application.Render(static_cast<unsigned int>(extendedDurationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
10038 // We did expect the animation to finish
10039 application.SendNotification();
10040 finishCheck.CheckSignalReceived();
10041 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
10045 int UtcDaliAnimationCustomIntProperty(void)
10047 TestApplication application;
10049 Actor actor = Actor::New();
10050 Stage::GetCurrent().Add(actor);
10051 int startValue(0u);
10053 Property::Index index = actor.RegisterProperty("anIndex", startValue);
10054 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
10056 // Build the animation
10057 float durationSeconds(1.0f);
10058 Animation animation = Animation::New(durationSeconds);
10059 animation.AnimateTo( Property(actor, index), 20 );
10061 // Start the animation
10064 bool signalReceived(false);
10065 AnimationFinishCheck finishCheck(signalReceived);
10066 animation.FinishedSignal().Connect(&application, finishCheck);
10068 application.SendNotification();
10069 application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
10071 // We didn't expect the animation to finish yet
10072 application.SendNotification();
10073 finishCheck.CheckSignalNotReceived();
10074 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), 10, TEST_LOCATION );
10076 application.SendNotification();
10077 application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
10079 // We did expect the animation to finish
10080 application.SendNotification();
10081 finishCheck.CheckSignalReceived();
10082 DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), 20, TEST_LOCATION );
10086 int UtcDaliAnimationDuration(void)
10088 TestApplication application;
10090 Actor actor = Actor::New();
10091 Stage::GetCurrent().Add(actor);
10093 Animation animation = Animation::New( 0.0f );
10094 DALI_TEST_EQUALS( 0.0f, animation.GetDuration(), TEST_LOCATION );
10096 // The animation duration should automatically increase depending on the animator time period
10098 animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 100.0f, TimePeriod( 0.0f, 1.0f ) );
10099 DALI_TEST_EQUALS( 1.0f, animation.GetDuration(), TEST_LOCATION );
10101 animation.AnimateTo( Property( actor, Actor::Property::POSITION_Y ), 200.0f, TimePeriod( 10.0f, 1.0f ) );
10102 DALI_TEST_EQUALS( 11.0f, animation.GetDuration(), TEST_LOCATION );
10107 int UtcDaliAnimationAnimateByNonAnimateableTypeN(void)
10109 TestApplication application;
10111 Actor actor = Actor::New();
10113 // Register an integer property
10115 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
10116 Stage::GetCurrent().Add(actor);
10117 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
10121 // Build the animation
10122 Animation animation = Animation::New( 2.0f );
10123 std::string relativeValue = "relative string";
10124 animation.AnimateBy( Property(actor, index), relativeValue );
10125 tet_result(TET_FAIL);
10127 catch ( Dali::DaliException& e )
10129 DALI_TEST_ASSERT( e, "Animated value and Property type don't match", TEST_LOCATION );
10137 int UtcDaliAnimationAnimateToNonAnimateableTypeN(void)
10139 TestApplication application;
10141 Actor actor = Actor::New();
10143 // Register an integer property
10145 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
10146 Stage::GetCurrent().Add(actor);
10147 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
10151 // Build the animation
10152 Animation animation = Animation::New( 2.0f );
10153 std::string relativeValue = "relative string";
10154 animation.AnimateTo( Property(actor, index), relativeValue );
10156 tet_result(TET_FAIL);
10158 catch ( Dali::DaliException& e )
10160 DALI_TEST_ASSERT( e, "Animated value and Property type don't match", TEST_LOCATION );
10166 int UtcDaliAnimationAnimateBetweenNonAnimateableTypeN(void)
10168 TestApplication application;
10170 Actor actor = Actor::New();
10172 // Register an integer property
10174 Property::Index index = actor.RegisterProperty( "testProperty", startValue );
10175 Stage::GetCurrent().Add(actor);
10176 DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
10180 // Build the animation
10181 KeyFrames keyFrames = KeyFrames::New();
10182 keyFrames.Add( 0.0f, std::string("relative string1") );
10183 keyFrames.Add( 1.0f, std::string("relative string2") );
10184 // no need to really create the animation as keyframes do the check
10186 tet_result(TET_FAIL);
10188 catch ( Dali::DaliException& e )
10190 DALI_TEST_ASSERT( e, "Type not animateable", TEST_LOCATION );
10196 int UtcDaliAnimationSetAndGetTargetBeforePlayP(void)
10198 tet_infoline("Setting up an animation should not effect it's position property until the animation plays");
10200 TestApplication application;
10202 tet_infoline("Set initial position and set up animation to re-position actor");
10204 Actor actor = Actor::New();
10205 Stage::GetCurrent().Add(actor);
10206 Vector3 initialPosition(0.0f, 0.0f, 0.0f);
10207 actor.SetProperty( Actor::Property::POSITION, initialPosition );
10209 // Build the animation
10210 Animation animation = Animation::New(2.0f);
10212 //Test GetCurrentProgress return 0.0 as the duration is 0.0
10213 DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
10214 DALI_TEST_EQUALS( Vector3( 0.0f, 0.0f, 0.0f ), actor.GetCurrentPosition(), TEST_LOCATION );
10216 tet_infoline("Set target position in animation without intiating play");
10218 Vector3 targetPosition(100.0f, 100.0f, 100.0f);
10219 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
10221 application.SendNotification();
10222 application.Render();
10224 tet_infoline("Ensure position of actor is still at intial value");
10226 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), initialPosition.x, TEST_LOCATION );
10227 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), initialPosition.y, TEST_LOCATION );
10228 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), initialPosition.z, TEST_LOCATION );
10230 tet_infoline("Play animation and ensure actor position is now target");
10233 application.SendNotification();
10234 application.Render(1000u);
10236 tet_infoline("Ensure position of actor is at target value when aninmation half way");
10238 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPosition.x, TEST_LOCATION );
10239 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPosition.y, TEST_LOCATION );
10240 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPosition.z, TEST_LOCATION );
10242 tet_printf( "x position at half way point(%f)\n", actor.GetCurrentPosition().x );
10244 application.Render(2000u);
10246 tet_infoline("Ensure position of actor is still at target value when aninmation complete");
10248 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPosition.x, TEST_LOCATION );
10249 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPosition.y, TEST_LOCATION );
10250 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPosition.z, TEST_LOCATION );
10255 int UtcDaliAnimationSetAndGetTargetBeforePlayMulitpleAnimatorsPositionP(void)
10257 tet_infoline("Setting up an animation should not effect it's position property until the animation plays even with mulitple animators");
10259 TestApplication application;
10261 std::vector<Vector3> targetPositions;
10263 targetPositions.push_back( Vector3( 100.0f, 100.0f, 100.0f ) );
10264 targetPositions.push_back( Vector3( 200.0f, 1.0f, 100.0f ) );
10265 targetPositions.push_back( Vector3( 50.0f, 10.0f, 100.0f ) );
10267 tet_infoline("Set initial position and set up animation to re-position actor");
10269 Actor actor = Actor::New();
10270 Stage::GetCurrent().Add(actor);
10271 Vector3 initialPosition(0.0f, 0.0f, 0.0f);
10272 actor.SetProperty( Actor::Property::POSITION, initialPosition );
10274 // Build the animation
10275 Animation animation = Animation::New(2.0f);
10277 //Test GetCurrentProgress return 0.0 as the duration is 0.0
10278 DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
10279 DALI_TEST_EQUALS( Vector3( 0.0f, 0.0f, 0.0f ), actor.GetCurrentPosition(), TEST_LOCATION );
10281 tet_infoline("Set target position in animation without intiating play");
10283 for ( unsigned int i = 0; i < targetPositions.size(); i++ )
10285 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPositions[i], AlphaFunction::LINEAR);
10288 application.SendNotification();
10289 application.Render();
10291 tet_infoline("Ensure position of actor is still at intial value");
10293 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), initialPosition.x, TEST_LOCATION );
10294 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), initialPosition.y, TEST_LOCATION );
10295 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), initialPosition.z, TEST_LOCATION );
10297 tet_infoline("Play animation and ensure actor position is now target");
10300 application.SendNotification();
10301 application.Render(1000u);
10303 tet_infoline("Ensure position of actor is at target value when aninmation half way");
10305 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[2].x, TEST_LOCATION );
10306 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[2].y, TEST_LOCATION );
10307 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[2].z, TEST_LOCATION );
10309 tet_printf( "x position at half way point(%f)\n", actor.GetCurrentPosition().x );
10311 application.Render(2000u);
10313 tet_infoline("Ensure position of actor is still at target value when aninmation complete");
10315 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[2].x, TEST_LOCATION );
10316 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[2].y, TEST_LOCATION );
10317 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[2].z, TEST_LOCATION );
10322 int UtcDaliAnimationSetAndGetTargetBeforePlayMulitpleAnimatorsSizeAndPositionP(void)
10324 tet_infoline("Setting up an animation should not effect it's size property until the animation plays even with mulitple animators of different Property Indexes");
10326 TestApplication application;
10328 std::vector<Vector3> targetSizes;
10329 std::vector<Vector3> targetPositions;
10331 targetSizes.push_back( Vector3( 100.0f, 100.0f, 100.0f ) );
10332 targetSizes.push_back( Vector3( 50.0f, 10.0f, 100.0f ) );
10334 targetPositions.push_back( Vector3( 200.0f, 1.0f, 100.0f ) );
10336 tet_infoline("Set initial position and set up animation to re-position actor");
10338 Actor actor = Actor::New();
10339 Stage::GetCurrent().Add(actor);
10340 Vector3 initialSize( 10.0f, 10.0f, 10.0f);
10341 Vector3 initialPosition(10.0f, 10.0f, 10.0f);
10343 actor.SetProperty( Actor::Property::SIZE, initialSize );
10344 actor.SetProperty( Actor::Property::POSITION, initialPosition );
10346 // Build the animation
10347 Animation animation = Animation::New(2.0f);
10349 tet_infoline("Set target size in animation without intiating play");
10350 animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSizes[0], AlphaFunction::LINEAR);
10351 tet_infoline("Set target position in animation without intiating play");
10352 animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPositions[0], AlphaFunction::LINEAR);
10353 animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSizes[1], AlphaFunction::LINEAR);
10355 application.SendNotification();
10356 application.Render();
10358 tet_infoline("Ensure position of actor is still at intial size and position");
10360 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialSize.x, TEST_LOCATION );
10361 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialSize.y, TEST_LOCATION );
10362 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialSize.z, TEST_LOCATION );
10364 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialPosition.x, TEST_LOCATION );
10365 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialPosition.y, TEST_LOCATION );
10366 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialPosition.z, TEST_LOCATION );
10368 tet_infoline("Play animation and ensure actor position and size is now matches targets");
10371 application.SendNotification();
10372 application.Render(2000u);
10374 tet_infoline("Ensure position and size of actor is at target value when aninmation playing");
10376 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSizes[1].x, TEST_LOCATION );
10377 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSizes[1].y, TEST_LOCATION );
10378 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSizes[1].z, TEST_LOCATION );
10380 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[0].x, TEST_LOCATION );
10381 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[0].y, TEST_LOCATION );
10382 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[0].z, TEST_LOCATION );
10387 int UtcDaliAnimationSetAndGetTargetBeforePlayMulitpleAnimatorsSizeAndPositionColourP(void)
10389 tet_infoline("Setting up an animation should not effect it's size property until the animation plays even if other Properties animated");
10391 TestApplication application;
10393 std::vector<Vector3> targetSizes;
10394 std::vector<float> targetColors;
10396 targetSizes.push_back( Vector3( 100.0f, 100.0f, 100.0f ) );
10397 targetSizes.push_back( Vector3( 50.0f, 10.0f, 150.0f ) );
10399 targetColors.push_back( 1.0f );
10401 tet_infoline("Set initial position and set up animation to re-position actor");
10403 Actor actor = Actor::New();
10404 Stage::GetCurrent().Add(actor);
10405 Vector3 initialSize( 10.0f, 5.0f, 10.0f);
10407 actor.SetProperty( Actor::Property::SIZE, initialSize );
10409 // Build the animation
10410 Animation animation = Animation::New(2.0f);
10412 tet_infoline("Set target size in animation without intiating play");
10413 animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSizes[0], AlphaFunction::LINEAR);
10414 tet_infoline("Set target position in animation without intiating play");
10415 animation.AnimateTo(Property(actor, Actor::Property::COLOR_RED), targetColors[0], AlphaFunction::LINEAR);
10416 animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSizes[1], AlphaFunction::LINEAR);
10418 application.SendNotification();
10419 application.Render();
10421 tet_infoline("Ensure position of actor is still at intial size and position");
10423 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialSize.x, TEST_LOCATION );
10424 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialSize.y, TEST_LOCATION );
10425 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialSize.z, TEST_LOCATION );
10427 tet_infoline("Play animation and ensure actor position and size is now matches targets");
10430 application.SendNotification();
10431 application.Render(2000u);
10433 tet_infoline("Ensure position and size of actor is at target value when aninmation playing");
10435 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSizes[1].x, TEST_LOCATION );
10436 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSizes[1].y, TEST_LOCATION );
10437 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSizes[1].z, TEST_LOCATION );
10439 DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), targetColors[0], TEST_LOCATION );