2 * Copyright (c) 2022 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.
18 #include <dali-test-suite-utils.h>
19 #include <dali/devel-api/common/stage.h>
20 #include <dali/integration-api/events/key-event-integ.h>
21 #include <dali/integration-api/events/touch-event-integ.h>
22 #include <dali/integration-api/events/wheel-event-integ.h>
23 #include <dali/integration-api/scene.h>
24 #include <dali/public-api/events/key-event.h>
25 #include <mesh-builder.h>
30 // Internal headers are allowed here
34 const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
36 // Functor for EventProcessingFinished signal
37 struct EventProcessingFinishedFunctor
40 * @param[in] eventProcessingFinished reference to a boolean variable used to check if signal has been called.
42 EventProcessingFinishedFunctor(bool& eventProcessingFinished)
43 : mEventProcessingFinished(eventProcessingFinished)
49 mEventProcessingFinished = true;
52 bool& mEventProcessingFinished;
55 // Stores data that is populated in the key-event callback and will be read by the TET cases
56 struct KeyEventSignalData
59 : functorCalled(false)
65 functorCalled = false;
67 receivedKeyEvent.Reset();
71 KeyEvent receivedKeyEvent;
74 // Functor that sets the data when called
75 struct KeyEventReceivedFunctor
77 KeyEventReceivedFunctor(KeyEventSignalData& data)
82 bool operator()(const KeyEvent& keyEvent)
84 signalData.functorCalled = true;
85 signalData.receivedKeyEvent = keyEvent;
90 KeyEventSignalData& signalData;
93 // Stores data that is populated in the touched signal callback and will be read by the TET cases
94 struct TouchedSignalData
97 : functorCalled(false),
98 createNewScene(false),
99 newSceneCreated(false)
105 functorCalled = false;
106 createNewScene = false;
107 newSceneCreated = false;
108 receivedTouchEvent.Reset();
113 bool newSceneCreated;
114 TouchEvent receivedTouchEvent;
117 // Functor that sets the data when touched signal is received
120 TouchFunctor(TouchedSignalData& data)
125 void operator()(const TouchEvent& touch)
127 signalData.functorCalled = true;
128 signalData.receivedTouchEvent = touch;
130 if(signalData.createNewScene)
132 Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
133 DALI_TEST_CHECK(scene);
135 signalData.newSceneCreated = true;
141 signalData.functorCalled = true;
144 TouchedSignalData& signalData;
147 // Stores data that is populated in the wheel-event callback and will be read by the TET cases
148 struct WheelEventSignalData
150 WheelEventSignalData()
151 : functorCalled(false)
157 functorCalled = false;
161 WheelEvent receivedWheelEvent;
164 // Functor that sets the data when wheel-event signal is received
165 struct WheelEventReceivedFunctor
167 WheelEventReceivedFunctor(WheelEventSignalData& data)
172 bool operator()(const WheelEvent& wheelEvent)
174 signalData.functorCalled = true;
175 signalData.receivedWheelEvent = wheelEvent;
180 WheelEventSignalData& signalData;
183 // Stores data that is populated in the KeyEventGeneratedSignal callback and will be read by the TET cases
184 struct KeyEventGeneratedSignalData
186 KeyEventGeneratedSignalData()
187 : functorCalled(false)
193 functorCalled = false;
195 receivedKeyEvent.Reset();
199 KeyEvent receivedKeyEvent;
202 // Functor that sets the data when called
203 struct KeyEventGeneratedReceivedFunctor
205 KeyEventGeneratedReceivedFunctor(KeyEventGeneratedSignalData& data)
210 bool operator()(const KeyEvent& keyEvent)
212 signalData.functorCalled = true;
213 signalData.receivedKeyEvent = keyEvent;
220 signalData.functorCalled = true;
224 KeyEventGeneratedSignalData& signalData;
227 // Stores data that is populated in the WheelEventGeneratedSignal callback and will be read by the TET cases
228 struct WheelEventGeneratedSignalData
230 WheelEventGeneratedSignalData()
231 : functorCalled(false)
237 functorCalled = false;
239 receivedWheelEvent.Reset();
243 WheelEvent receivedWheelEvent;
246 // Functor that sets the data when called
247 struct WheelEventGeneratedReceivedFunctor
249 WheelEventGeneratedReceivedFunctor(WheelEventGeneratedSignalData& data)
254 bool operator()(const WheelEvent& wheelEvent)
256 signalData.functorCalled = true;
257 signalData.receivedWheelEvent = wheelEvent;
264 signalData.functorCalled = true;
268 WheelEventGeneratedSignalData& signalData;
271 void GenerateTouch(TestApplication& application, PointState::Type state, const Vector2& screenPosition)
273 Integration::TouchEvent touchEvent;
274 Integration::Point point;
275 point.SetState(state);
276 point.SetScreenPosition(screenPosition);
277 touchEvent.points.push_back(point);
278 application.ProcessEvent(touchEvent);
281 bool DummyTouchCallback(Actor actor, const TouchEvent& touch)
286 void FrameCallback(int frameId)
290 } // unnamed namespace
292 int UtcDaliSceneAdd(void)
294 TestApplication application;
295 tet_infoline("Testing Dali::Integration::Scene::Add");
297 Dali::Integration::Scene scene = application.GetScene();
299 Actor actor = Actor::New();
300 DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
303 DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
308 int UtcDaliSceneRemove(void)
310 TestApplication application;
311 tet_infoline("Testing Dali::Integration::Scene::Remove");
313 Dali::Integration::Scene scene = application.GetScene();
315 Actor actor = Actor::New();
316 DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
319 DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
322 DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
327 int UtcDaliSceneGetSize(void)
329 TestApplication application;
330 tet_infoline("Testing Dali::Integration::Scene::GetSize");
332 Dali::Integration::Scene scene = application.GetScene();
333 Size size = scene.GetSize();
334 DALI_TEST_EQUALS(TestApplication::DEFAULT_SURFACE_WIDTH, size.width, TEST_LOCATION);
335 DALI_TEST_EQUALS(TestApplication::DEFAULT_SURFACE_HEIGHT, size.height, TEST_LOCATION);
340 int UtcDaliSceneGetDpi(void)
342 TestApplication application; // Initializes core DPI to default values
344 // Test that setting core DPI explicitly also sets up the scene's DPI.
345 Dali::Integration::Scene scene = application.GetScene();
346 scene.SetDpi(Vector2(200.0f, 180.0f));
347 Vector2 dpi = scene.GetDpi();
348 DALI_TEST_EQUALS(dpi.x, 200.0f, TEST_LOCATION);
349 DALI_TEST_EQUALS(dpi.y, 180.0f, TEST_LOCATION);
353 int UtcDaliSceneGetRenderTaskList(void)
355 TestApplication application;
356 tet_infoline("Testing Dali::Integration::Scene::GetRenderTaskList");
358 Dali::Integration::Scene scene = application.GetScene();
360 // Check we get a valid instance.
361 const RenderTaskList& tasks = scene.GetRenderTaskList();
363 // There should be 1 task by default.
364 DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION);
366 // RenderTaskList has it's own UTC tests.
367 // But we can confirm that GetRenderTaskList in Stage retrieves the same RenderTaskList each time.
368 RenderTask newTask = scene.GetRenderTaskList().CreateTask();
370 DALI_TEST_EQUALS(scene.GetRenderTaskList().GetTask(1), newTask, TEST_LOCATION);
375 int UtcDaliSceneGetRootLayer(void)
377 TestApplication application;
378 tet_infoline("Testing Dali::Integration::Scene::GetRootLayer");
380 Dali::Integration::Scene scene = application.GetScene();
381 Layer layer = scene.GetLayer(0);
382 DALI_TEST_CHECK(layer);
384 // Check that GetRootLayer() correctly retreived layer 0.
385 DALI_TEST_CHECK(scene.GetRootLayer() == layer);
390 int UtcDaliSceneGetLayerCount(void)
392 TestApplication application;
393 tet_infoline("Testing Dali::Integration::Scene::GetLayerCount");
395 Dali::Integration::Scene scene = application.GetScene();
396 // Initially we have a default layer
397 DALI_TEST_EQUALS(scene.GetLayerCount(), 1u, TEST_LOCATION);
399 Layer layer = Layer::New();
402 DALI_TEST_EQUALS(scene.GetLayerCount(), 2u, TEST_LOCATION);
406 int UtcDaliSceneGetLayer(void)
408 TestApplication application;
409 tet_infoline("Testing Dali::Integration::Scene::GetLayer");
411 Dali::Integration::Scene scene = application.GetScene();
413 Layer rootLayer = scene.GetLayer(0);
414 DALI_TEST_CHECK(rootLayer);
416 Layer layer = Layer::New();
419 Layer sameLayer = scene.GetLayer(1);
420 DALI_TEST_CHECK(layer == sameLayer);
425 int UtcDaliSceneGet(void)
427 TestApplication application;
428 tet_infoline("Testing Dali::Integration::Scene::Get");
430 Dali::Integration::Scene scene = application.GetScene();
432 Actor parent = Actor::New();
433 Actor child = Actor::New();
437 // Should be empty scene
438 DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(parent));
439 DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(child));
443 // Should return the valid scene
444 DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(parent));
445 DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(child));
449 // Should be empty scene
450 DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(parent));
451 DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(child));
456 int UtcDaliSceneDiscard(void)
458 TestApplication application;
459 tet_infoline("Testing Dali::Scene::Discard");
461 // Create a new Scene
462 Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
463 DALI_TEST_CHECK(scene);
465 // One reference of scene kept here and the other one kept in the Core
466 DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 2);
468 // Render and notify.
469 application.SendNotification();
470 application.Render(0);
472 // Keep the reference of the root layer handle so it will still be alive after the scene is deleted
473 Layer rootLayer = scene.GetRootLayer();
474 DALI_TEST_CHECK(rootLayer);
475 DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 2);
477 // Request to discard the scene from the Core
479 DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 1);
481 // Reset the scene handle
484 // Render and notify.
485 application.SendNotification();
486 application.Render(0);
488 // At this point, the scene should have been automatically deleted
489 // To prove this, the ref count of the root layer handle should be decremented to 1
490 DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
492 // Delete the root layer handle
495 // Render and notify.
496 application.SendNotification();
497 application.Render(0);
502 int UtcDaliSceneCreateNewSceneDuringCoreEventProcessing(void)
504 TestApplication application;
506 Dali::Integration::Scene scene = application.GetScene();
508 TouchedSignalData data;
509 data.createNewScene = true;
510 TouchFunctor functor(data);
511 scene.TouchedSignal().Connect(&application, functor);
513 // Render and notify.
514 application.SendNotification();
515 application.Render();
517 GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
519 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
520 DALI_TEST_EQUALS(true, data.createNewScene, TEST_LOCATION);
521 DALI_TEST_EQUALS(true, data.newSceneCreated, TEST_LOCATION);
527 int UtcDaliSceneRootLayerAndSceneAlignment(void)
529 TestApplication application;
532 Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
533 DALI_TEST_CHECK(scene);
535 // One reference of scene kept here and the other one kept in the Core
536 DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 2);
538 // Add a renderable actor to the scene
539 auto actor = CreateRenderableActor();
542 // Render and notify.
543 application.SendNotification();
544 application.Render(0);
546 // Keep the reference of the root layer handle so it will still be alive after the scene is deleted
547 Layer rootLayer = scene.GetRootLayer();
548 DALI_TEST_CHECK(rootLayer);
549 DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 2);
551 // Request to discard the scene from the Core
553 DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 1);
555 // Reset the scene handle
558 // Render and notify.
559 application.SendNotification();
560 application.Render(0);
562 // At this point, the scene should have been automatically deleted
563 // To prove this, the ref count of the root layer handle should be decremented to 1
564 DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
566 // Create a new Scene while the root layer of the deleted scene is still alive
567 Dali::Integration::Scene newScene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
568 DALI_TEST_CHECK(newScene);
570 // Render and notify.
571 application.SendNotification();
572 application.Render(0);
574 // At this point, we have only one scene but two root layers
575 // The root layer of the deleted scene is still alive
576 DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
578 // Delete the root layer of the deleted scene
581 // Render and notify.
582 application.SendNotification();
583 application.Render(0);
588 int UtcDaliSceneEventProcessingFinishedP(void)
590 TestApplication application;
591 Dali::Integration::Scene scene = application.GetScene();
593 bool eventProcessingFinished = false;
594 EventProcessingFinishedFunctor functor(eventProcessingFinished);
595 scene.EventProcessingFinishedSignal().Connect(&application, functor);
597 Actor actor(Actor::New());
600 application.SendNotification();
601 application.Render();
603 DALI_TEST_CHECK(eventProcessingFinished);
608 int UtcDaliSceneEventProcessingFinishedN(void)
610 TestApplication application;
611 Dali::Integration::Scene scene = application.GetScene();
613 bool eventProcessingFinished = false;
614 EventProcessingFinishedFunctor functor(eventProcessingFinished);
615 scene.EventProcessingFinishedSignal().Connect(&application, functor);
617 Actor actor(Actor::New());
620 // Do not complete event processing and confirm the signal has not been emitted.
621 DALI_TEST_CHECK(!eventProcessingFinished);
626 int UtcDaliSceneSignalKeyEventP(void)
628 TestApplication application;
629 Dali::Integration::Scene scene = application.GetScene();
631 KeyEventSignalData data;
632 KeyEventReceivedFunctor functor(data);
633 scene.KeyEventSignal().Connect(&application, functor);
635 Integration::KeyEvent event("i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
636 application.ProcessEvent(event);
638 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
639 DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
640 DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
641 DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
642 DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
646 Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
647 application.ProcessEvent(event2);
649 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
650 DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
651 DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
652 DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
653 DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
657 Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
658 application.ProcessEvent(event3);
660 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
661 DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
662 DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
663 DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
664 DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
668 Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
669 application.ProcessEvent(event4);
671 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
672 DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
673 DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
674 DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
675 DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
679 int UtcDaliSceneSignalKeyEventN(void)
681 TestApplication application;
682 Dali::Integration::Scene scene = application.GetScene();
684 KeyEventSignalData data;
685 KeyEventReceivedFunctor functor(data);
686 scene.KeyEventSignal().Connect(&application, functor);
688 // Check that a non-pressed key events data is not modified.
689 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
694 int UtcDaliSceneTouchedSignalP(void)
696 TestApplication application;
697 Dali::Integration::Scene scene = application.GetScene();
699 TouchedSignalData data;
700 TouchFunctor functor(data);
701 scene.TouchedSignal().Connect(&application, functor);
703 // Render and notify.
704 application.SendNotification();
705 application.Render();
707 // Basic test: No actors, single touch (down then up).
709 GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
711 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
712 DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
713 DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
716 GenerateTouch(application, PointState::UP, Vector2(10.0f, 10.0f));
718 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
719 DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
720 DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
724 // Add an actor to the scene.
725 Actor actor = Actor::New();
726 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
727 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
728 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
729 actor.TouchedSignal().Connect(&DummyTouchCallback);
732 // Render and notify.
733 application.SendNotification();
734 application.Render();
736 // Actor on scene, single touch, down in actor, motion, then up outside actor.
738 GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
740 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
741 DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
742 DALI_TEST_CHECK(data.receivedTouchEvent.GetHitActor(0) == actor);
745 GenerateTouch(application, PointState::MOTION, Vector2(150.0f, 10.0f)); // Some motion
747 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
750 GenerateTouch(application, PointState::UP, Vector2(150.0f, 10.0f)); // Some motion
752 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
753 DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
754 DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
758 // Multiple touch. Should only receive a touch on first down and last up.
760 Integration::TouchEvent touchEvent;
761 Integration::Point point;
764 point.SetState(PointState::DOWN);
765 point.SetScreenPosition(Vector2(10.0f, 10.0f));
766 touchEvent.points.push_back(point);
767 application.ProcessEvent(touchEvent);
768 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
769 DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
773 touchEvent.points[0].SetState(PointState::STATIONARY);
774 point.SetDeviceId(1);
775 point.SetScreenPosition(Vector2(50.0f, 50.0f));
776 touchEvent.points.push_back(point);
777 application.ProcessEvent(touchEvent);
778 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
781 // Primary point is up
782 touchEvent.points[0].SetState(PointState::UP);
783 touchEvent.points[1].SetState(PointState::STATIONARY);
784 application.ProcessEvent(touchEvent);
785 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
788 // Remove 1st point now, 2nd point is now in motion
789 touchEvent.points.erase(touchEvent.points.begin());
790 touchEvent.points[0].SetState(PointState::MOTION);
791 touchEvent.points[0].SetScreenPosition(Vector2(150.0f, 50.0f));
792 application.ProcessEvent(touchEvent);
793 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
797 touchEvent.points[0].SetState(PointState::UP);
798 application.ProcessEvent(touchEvent);
799 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
800 DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
806 int UtcDaliSceneTouchedSignalN(void)
808 TestApplication application;
809 Dali::Integration::Scene scene = application.GetScene();
811 TouchedSignalData data;
812 TouchFunctor functor(data);
813 scene.TouchedSignal().Connect(&application, functor);
815 // Render and notify.
816 application.SendNotification();
817 application.Render();
819 // Confirm functor not called before there has been any touch event.
820 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
822 // No actors, single touch, down, motion then up.
824 GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
826 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
827 DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
828 DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
832 // Confirm there is no signal when the touchpoint is only moved.
833 GenerateTouch(application, PointState::MOTION, Vector2(1200.0f, 10.0f)); // Some motion
835 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
838 // Confirm a following up event generates a signal.
839 GenerateTouch(application, PointState::UP, Vector2(1200.0f, 10.0f));
841 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
842 DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
843 DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
847 // Add an actor to the scene.
848 Actor actor = Actor::New();
849 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
850 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
851 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
852 actor.TouchedSignal().Connect(&DummyTouchCallback);
855 // Render and notify.
856 application.SendNotification();
857 application.Render();
859 // Actor on scene. Interrupted before down and interrupted after down.
861 GenerateTouch(application, PointState::INTERRUPTED, Vector2(10.0f, 10.0f));
863 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
864 DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
865 DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
866 DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED);
869 GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
871 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
872 DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
873 DALI_TEST_CHECK(data.receivedTouchEvent.GetHitActor(0) == actor);
874 DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::DOWN);
877 GenerateTouch(application, PointState::INTERRUPTED, Vector2(10.0f, 10.0f));
879 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
880 DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
881 DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
882 DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED);
884 DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
886 // Check that getting info about a non-existent point returns an empty handle
887 Actor actor = data.receivedTouchEvent.GetHitActor(1);
888 DALI_TEST_CHECK(!actor);
896 int UtcDaliSceneSignalWheelEventP(void)
898 TestApplication application;
899 Dali::Integration::Scene scene = application.GetScene();
901 WheelEventSignalData data;
902 WheelEventReceivedFunctor functor(data);
903 scene.WheelEventSignal().Connect(&application, functor);
905 Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
906 application.ProcessEvent(event);
908 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
909 DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event.type) == data.receivedWheelEvent.GetType());
910 DALI_TEST_CHECK(event.direction == data.receivedWheelEvent.GetDirection());
911 DALI_TEST_CHECK(event.modifiers == data.receivedWheelEvent.GetModifiers());
912 DALI_TEST_CHECK(event.point == data.receivedWheelEvent.GetPoint());
913 DALI_TEST_CHECK(event.delta == data.receivedWheelEvent.GetDelta());
914 DALI_TEST_CHECK(event.timeStamp == data.receivedWheelEvent.GetTime());
918 Integration::WheelEvent event2(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1000u);
919 application.ProcessEvent(event2);
921 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
922 DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event2.type) == data.receivedWheelEvent.GetType());
923 DALI_TEST_CHECK(event2.direction == data.receivedWheelEvent.GetDirection());
924 DALI_TEST_CHECK(event2.modifiers == data.receivedWheelEvent.GetModifiers());
925 DALI_TEST_CHECK(event2.point == data.receivedWheelEvent.GetPoint());
926 DALI_TEST_CHECK(event2.delta == data.receivedWheelEvent.GetDelta());
927 DALI_TEST_CHECK(event2.timeStamp == data.receivedWheelEvent.GetTime());
931 int UtcDaliSceneSurfaceResizedDefaultScene(void)
933 tet_infoline("Ensure resizing of the surface is handled properly");
935 TestApplication application;
937 auto defaultScene = application.GetScene();
938 DALI_TEST_CHECK(defaultScene);
940 // Ensure stage size matches the scene size
941 auto stage = Stage::GetCurrent();
942 DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
945 Vector2 newSize(1000.0f, 2000.0f);
946 DALI_TEST_CHECK(stage.GetSize() != newSize);
947 defaultScene.SurfaceResized(newSize.width, newSize.height);
949 DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
950 DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
955 int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void)
957 tet_infoline("Ensure resizing of the surface & viewport is handled properly");
959 TestApplication application;
960 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
961 TraceCallStack& callStack = glAbstraction.GetViewportTrace();
962 glAbstraction.EnableViewportCallTrace(true);
964 // Initial scene setup
965 Geometry geometry = CreateQuadGeometry();
966 Shader shader = CreateShader();
967 Renderer renderer = Renderer::New(geometry, shader);
969 Actor actor = Actor::New();
970 actor.AddRenderer(renderer);
971 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
972 application.GetScene().Add(actor);
974 // Render before resizing surface
975 application.SendNotification();
976 application.Render(0);
977 glAbstraction.ResetViewportCallStack();
979 auto defaultScene = application.GetScene();
980 DALI_TEST_CHECK(defaultScene);
982 // consume the resize flag by first rendering
983 defaultScene.IsSurfaceRectChanged();
985 // Ensure stage size matches the scene size
986 auto stage = Stage::GetCurrent();
987 DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
989 Rect<int32_t> surfaceRect = defaultScene.GetCurrentSurfaceRect();
992 // check resized flag before surface is resized.
993 surfaceResized = defaultScene.IsSurfaceRectChanged();
994 DALI_TEST_EQUALS(surfaceResized, false, TEST_LOCATION);
997 Vector2 newSize(1000.0f, 2000.0f);
998 std::string viewportParams("0, 0, 1000, 2000"); // to match newSize
999 DALI_TEST_CHECK(stage.GetSize() != newSize);
1000 defaultScene.SurfaceResized(newSize.width, newSize.height);
1002 DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
1003 DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
1005 // Check current surface rect
1006 Rect<int32_t> newSurfaceRect = defaultScene.GetCurrentSurfaceRect();
1008 // It should not be changed yet.
1009 DALI_TEST_CHECK(surfaceRect == newSurfaceRect);
1011 // Render after resizing surface
1012 application.SendNotification();
1013 application.Render(0);
1015 surfaceResized = defaultScene.IsSurfaceRectChanged();
1016 DALI_TEST_EQUALS(surfaceResized, true, TEST_LOCATION);
1018 // Check that the viewport is handled properly
1019 DALI_TEST_CHECK(callStack.FindIndexFromMethodAndParams("Viewport", viewportParams) >= 0);
1021 // Check current surface rect
1022 newSurfaceRect = defaultScene.GetCurrentSurfaceRect();
1024 // It should be changed
1025 DALI_TEST_EQUALS(newSurfaceRect.x, 0, TEST_LOCATION);
1026 DALI_TEST_EQUALS(newSurfaceRect.y, 0, TEST_LOCATION);
1027 DALI_TEST_EQUALS(newSurfaceRect.width, 1000, TEST_LOCATION);
1028 DALI_TEST_EQUALS(newSurfaceRect.height, 2000, TEST_LOCATION);
1033 int UtcDaliSceneSurfaceResizedMultipleRenderTasks(void)
1035 tet_infoline("Ensure resizing of the surface & viewport is handled properly");
1037 TestApplication application;
1038 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1039 TraceCallStack& callStack = glAbstraction.GetViewportTrace();
1040 glAbstraction.EnableViewportCallTrace(true);
1042 // Initial scene setup
1043 auto scene = application.GetScene();
1045 Geometry geometry = CreateQuadGeometry();
1046 Shader shader = CreateShader();
1047 Renderer renderer = Renderer::New(geometry, shader);
1049 Actor actor = Actor::New();
1050 actor.AddRenderer(renderer);
1051 int testWidth = 400;
1052 int testHeight = 400;
1053 actor.SetProperty(Actor::Property::SIZE, Vector2(testWidth, testHeight));
1056 CameraActor offscreenCameraActor = CameraActor::New(Size(testWidth, testHeight));
1057 application.GetScene().Add(offscreenCameraActor);
1059 FrameBuffer newFrameBuffer = FrameBuffer::New(testWidth, testHeight, FrameBuffer::Attachment::NONE);
1061 RenderTask newTask = scene.GetRenderTaskList().CreateTask();
1062 newTask.SetCameraActor(offscreenCameraActor);
1063 newTask.SetSourceActor(actor);
1064 newTask.SetFrameBuffer(newFrameBuffer);
1065 newTask.SetViewportPosition(Vector2(0, 0));
1066 newTask.SetViewportSize(Vector2(testWidth, testHeight));
1068 // Render before resizing surface
1069 application.SendNotification();
1070 application.Render(0);
1071 glAbstraction.ResetViewportCallStack();
1073 Rect<int32_t> initialViewport = newTask.GetViewport();
1074 int initialWidth = initialViewport.width;
1075 int initialHeight = initialViewport.height;
1076 DALI_TEST_EQUALS(initialWidth, testWidth, TEST_LOCATION);
1077 DALI_TEST_EQUALS(initialHeight, testHeight, TEST_LOCATION);
1079 auto defaultScene = application.GetScene();
1080 DALI_TEST_CHECK(defaultScene);
1082 // Ensure stage size matches the scene size
1083 auto stage = Stage::GetCurrent();
1084 DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
1087 Vector2 newSize(1000.0f, 2000.0f);
1088 std::string viewportParams("0, 0, 1000, 2000"); // to match newSize
1089 DALI_TEST_CHECK(stage.GetSize() != newSize);
1090 defaultScene.SurfaceResized(newSize.width, newSize.height);
1092 DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
1093 DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
1095 // Render after resizing surface
1096 application.SendNotification();
1097 application.Render(0);
1099 // Check that the viewport is handled properly
1100 DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams));
1102 // Second render-task should not be affected
1103 Rect<int32_t> viewport = newTask.GetViewport();
1104 int width = viewport.width;
1105 int height = viewport.height;
1106 DALI_TEST_EQUALS(width, testWidth, TEST_LOCATION);
1107 DALI_TEST_EQUALS(height, testHeight, TEST_LOCATION);
1112 int UtcDaliSceneSurfaceResizedAdditionalScene(void)
1114 tet_infoline("Ensure resizing of the surface is handled properly on additional scenes");
1116 TestApplication application;
1117 Vector2 originalSurfaceSize(500.0f, 1000.0f);
1119 auto scene = Integration::Scene::New(Size(originalSurfaceSize.width, originalSurfaceSize.height));
1121 // Ensure stage size does NOT match the surface size
1122 auto stage = Stage::GetCurrent();
1123 const auto stageSize = stage.GetSize();
1124 DALI_TEST_CHECK(stageSize != originalSurfaceSize);
1125 DALI_TEST_EQUALS(originalSurfaceSize, scene.GetSize(), TEST_LOCATION);
1127 // Resize the surface and inform the scene accordingly
1128 Vector2 newSize(1000.0f, 2000.0f);
1129 DALI_TEST_CHECK(stage.GetSize() != newSize);
1130 scene.SurfaceResized(newSize.width, newSize.height);
1132 // Ensure the stage hasn't been resized
1133 DALI_TEST_EQUALS(stage.GetSize(), stageSize, TEST_LOCATION);
1134 DALI_TEST_EQUALS(scene.GetSize(), newSize, TEST_LOCATION);
1139 #define CLIPPING_RECT_X (16)
1140 #define CLIPPING_RECT_Y (768)
1141 #define CLIPPING_RECT_WIDTH (32)
1142 #define CLIPPING_RECT_HEIGHT (32)
1144 int UtcDaliSceneSurfaceRotatedWithAngle0(void)
1146 tet_infoline("Ensure rotation of the surface is handled properly with Angle 0");
1148 TestApplication application(
1149 TestApplication::DEFAULT_SURFACE_WIDTH,
1150 TestApplication::DEFAULT_SURFACE_HEIGHT,
1151 TestApplication::DEFAULT_HORIZONTAL_DPI,
1152 TestApplication::DEFAULT_VERTICAL_DPI,
1156 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1158 std::vector<Rect<int>> damagedRects;
1159 Rect<int> clippingRect;
1160 application.SendNotification();
1161 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1163 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1165 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1166 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1168 Actor actor = CreateRenderableActor();
1169 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1170 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1171 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1172 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1173 application.GetScene().Add(actor);
1175 // consume the orientating changing flag by first rendering
1176 application.SendNotification();
1178 damagedRects.clear();
1179 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1180 TestApplication::DEFAULT_SURFACE_HEIGHT,
1183 // Check current orientations
1184 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1185 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1187 // It should not be changed yet.
1188 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1189 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1191 application.SendNotification();
1192 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1193 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1195 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1196 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1197 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1199 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1200 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1201 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1202 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1204 // Check current orientations
1205 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1206 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1208 // It should be changed.
1209 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1210 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1215 int UtcDaliSceneSurfaceRotatedWithAngle90(void)
1217 tet_infoline("Ensure rotation of the surface is handled properly with Angle 90");
1219 TestApplication application(
1220 TestApplication::DEFAULT_SURFACE_WIDTH,
1221 TestApplication::DEFAULT_SURFACE_HEIGHT,
1222 TestApplication::DEFAULT_HORIZONTAL_DPI,
1223 TestApplication::DEFAULT_VERTICAL_DPI,
1227 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1229 std::vector<Rect<int>> damagedRects;
1230 Rect<int> clippingRect;
1231 application.SendNotification();
1232 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1234 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1236 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1237 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1239 Actor actor = CreateRenderableActor();
1240 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1241 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1242 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1243 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1244 application.GetScene().Add(actor);
1246 application.SendNotification();
1248 damagedRects.clear();
1249 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1250 TestApplication::DEFAULT_SURFACE_HEIGHT,
1253 // Check current surface orientation
1254 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1255 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1257 // It should not be changed yet.
1258 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1259 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1261 application.SendNotification();
1262 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1263 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1265 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1266 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1267 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1269 // It is recalculation for glScissor.
1270 // Because surface is rotated and glScissor is called with recalcurated value.
1271 // Total angle is 90, (90 + 0 = 90)
1272 clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1273 clippingRect.y = CLIPPING_RECT_X;
1274 clippingRect.width = CLIPPING_RECT_HEIGHT;
1275 clippingRect.height = CLIPPING_RECT_WIDTH;
1277 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1278 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1279 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1280 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1282 // Check current orientations
1283 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1284 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1286 // It should be changed.
1287 DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION);
1288 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1293 int UtcDaliSceneScreenRotatedWithAngle90(void)
1295 tet_infoline("Ensure rotation of the screen is handled properly with Angle 90");
1297 TestApplication application(
1298 TestApplication::DEFAULT_SURFACE_WIDTH,
1299 TestApplication::DEFAULT_SURFACE_HEIGHT,
1300 TestApplication::DEFAULT_HORIZONTAL_DPI,
1301 TestApplication::DEFAULT_VERTICAL_DPI,
1305 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1307 std::vector<Rect<int>> damagedRects;
1308 Rect<int> clippingRect;
1309 application.SendNotification();
1310 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1312 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1314 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1315 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1317 Actor actor = CreateRenderableActor();
1318 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1319 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1320 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1321 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1322 application.GetScene().Add(actor);
1324 application.SendNotification();
1326 damagedRects.clear();
1327 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1328 TestApplication::DEFAULT_SURFACE_HEIGHT,
1331 // Check current surface orientation
1332 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1333 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1335 // It should not be changed yet.
1336 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1337 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1339 application.SendNotification();
1340 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1341 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1343 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1344 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1345 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1347 // It is recalculation for glScissor.
1348 // Because surface is rotated and glScissor is called with recalcurated value.
1349 // Total angle is 90, (0 + 90 = 90)
1350 clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1351 clippingRect.y = CLIPPING_RECT_X;
1352 clippingRect.width = CLIPPING_RECT_HEIGHT;
1353 clippingRect.height = CLIPPING_RECT_WIDTH;
1355 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1356 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1357 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1358 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1360 // Check current orientations
1361 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1362 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1364 // It should be changed.
1365 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1366 DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION);
1371 int UtcDaliSceneSurfaceAndScreenRotatedWithAngle90(void)
1373 tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 90");
1375 TestApplication application(
1376 TestApplication::DEFAULT_SURFACE_WIDTH,
1377 TestApplication::DEFAULT_SURFACE_HEIGHT,
1378 TestApplication::DEFAULT_HORIZONTAL_DPI,
1379 TestApplication::DEFAULT_VERTICAL_DPI,
1383 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1385 std::vector<Rect<int>> damagedRects;
1386 Rect<int> clippingRect;
1387 application.SendNotification();
1388 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1390 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1392 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1393 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1395 Actor actor = CreateRenderableActor();
1396 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1397 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1398 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1399 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1400 application.GetScene().Add(actor);
1402 application.SendNotification();
1404 damagedRects.clear();
1405 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1406 TestApplication::DEFAULT_SURFACE_HEIGHT,
1409 // Check current surface orientation
1410 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1411 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1413 // It should not be changed yet.
1414 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1415 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1417 application.SendNotification();
1418 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1419 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1421 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1422 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1423 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1425 // It is recalculation for glScissor.
1426 // Because surface is rotated and glScissor is called with recalcurated value.
1427 // Total angle is 180.(90 + 90 = 180)
1428 clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
1429 clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1430 clippingRect.width = CLIPPING_RECT_WIDTH;
1431 clippingRect.height = CLIPPING_RECT_HEIGHT;
1433 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1434 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1435 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1436 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1438 // Check current orientations
1439 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1440 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1442 // It should be changed.
1443 DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION);
1444 DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION);
1449 int UtcDaliSceneSurfaceRotatedWithAngle180(void)
1451 tet_infoline("Ensure rotation of the surface is handled properly with Angle 180");
1453 TestApplication application(
1454 TestApplication::DEFAULT_SURFACE_WIDTH,
1455 TestApplication::DEFAULT_SURFACE_HEIGHT,
1456 TestApplication::DEFAULT_HORIZONTAL_DPI,
1457 TestApplication::DEFAULT_VERTICAL_DPI,
1461 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1463 std::vector<Rect<int>> damagedRects;
1464 Rect<int> clippingRect;
1465 application.SendNotification();
1466 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1468 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1470 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1471 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1473 Actor actor = CreateRenderableActor();
1474 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1475 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1476 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1477 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1478 application.GetScene().Add(actor);
1480 application.SendNotification();
1482 damagedRects.clear();
1483 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1484 TestApplication::DEFAULT_SURFACE_HEIGHT,
1487 // Check current surface orientation
1488 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1489 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1491 // It should not be changed yet.
1492 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1493 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1495 application.SendNotification();
1496 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1497 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1499 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1500 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1501 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1503 // It is recalculation for glScissor.
1504 // Because surface is rotated and glScissor is called with recalcurated value.
1505 clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
1506 clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1507 clippingRect.width = CLIPPING_RECT_WIDTH;
1508 clippingRect.height = CLIPPING_RECT_HEIGHT;
1510 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1511 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1512 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1513 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1515 // Check current orientations
1516 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1517 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1519 // It should be changed.
1520 DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION);
1521 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1526 int UtcDaliSceneScreenRotatedWithAngle180(void)
1528 tet_infoline("Ensure rotation of the screen is handled properly with Angle 180");
1530 TestApplication application(
1531 TestApplication::DEFAULT_SURFACE_WIDTH,
1532 TestApplication::DEFAULT_SURFACE_HEIGHT,
1533 TestApplication::DEFAULT_HORIZONTAL_DPI,
1534 TestApplication::DEFAULT_VERTICAL_DPI,
1538 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1540 std::vector<Rect<int>> damagedRects;
1541 Rect<int> clippingRect;
1542 application.SendNotification();
1543 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1545 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1547 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1548 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1550 Actor actor = CreateRenderableActor();
1551 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1552 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1553 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1554 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1555 application.GetScene().Add(actor);
1557 application.SendNotification();
1559 damagedRects.clear();
1560 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1561 TestApplication::DEFAULT_SURFACE_HEIGHT,
1564 // Check current surface orientation
1565 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1566 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1568 // It should not be changed yet.
1569 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1570 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1572 application.SendNotification();
1573 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1574 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1576 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1577 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1578 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1580 // It is recalculation for glScissor.
1581 // Because surface is rotated and glScissor is called with recalcurated value.
1582 clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
1583 clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1584 clippingRect.width = CLIPPING_RECT_WIDTH;
1585 clippingRect.height = CLIPPING_RECT_HEIGHT;
1587 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1588 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1589 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1590 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1592 // Check current orientations
1593 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1594 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1596 // It should be changed.
1597 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1598 DALI_TEST_EQUALS(screenOrientation, 180, TEST_LOCATION);
1603 int UtcDaliSceneSurfaceAndScreenRotatedWithAngle180(void)
1605 tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 180");
1607 TestApplication application(
1608 TestApplication::DEFAULT_SURFACE_WIDTH,
1609 TestApplication::DEFAULT_SURFACE_HEIGHT,
1610 TestApplication::DEFAULT_HORIZONTAL_DPI,
1611 TestApplication::DEFAULT_VERTICAL_DPI,
1615 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1617 std::vector<Rect<int>> damagedRects;
1618 Rect<int> clippingRect;
1619 application.SendNotification();
1620 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1622 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1624 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1625 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1627 Actor actor = CreateRenderableActor();
1628 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1629 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1630 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1631 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1632 application.GetScene().Add(actor);
1634 // consume the orientating changing flag by first rendering
1635 application.SendNotification();
1637 damagedRects.clear();
1638 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1639 TestApplication::DEFAULT_SURFACE_HEIGHT,
1642 // Check current orientations
1643 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1644 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1646 // It should not be changed yet.
1647 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1648 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1650 application.SendNotification();
1651 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1652 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1654 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1655 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1656 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1658 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1659 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1660 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1661 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1663 // Check current orientations
1664 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1665 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1667 // It should be changed.
1668 DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION);
1669 DALI_TEST_EQUALS(screenOrientation, 180, TEST_LOCATION);
1674 int UtcDaliSceneSurfaceRotatedWithAngle270(void)
1676 tet_infoline("Ensure rotation of the surface is handled properly with Angle 270");
1678 TestApplication application(
1679 TestApplication::DEFAULT_SURFACE_WIDTH,
1680 TestApplication::DEFAULT_SURFACE_HEIGHT,
1681 TestApplication::DEFAULT_HORIZONTAL_DPI,
1682 TestApplication::DEFAULT_VERTICAL_DPI,
1686 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1688 std::vector<Rect<int>> damagedRects;
1689 Rect<int> clippingRect;
1690 application.SendNotification();
1691 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1693 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1695 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1696 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1698 Actor actor = CreateRenderableActor();
1699 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1700 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1701 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1702 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1703 application.GetScene().Add(actor);
1705 application.SendNotification();
1707 damagedRects.clear();
1708 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1709 TestApplication::DEFAULT_SURFACE_HEIGHT,
1712 // Check current surface orientation
1713 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1714 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1716 // It should not be changed yet.
1717 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1718 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1720 application.SendNotification();
1721 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1722 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1724 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1725 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1726 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1728 // It is recalculation for glScissor.
1729 // Because surface is rotated and glScissor is called with recalcurated value.
1730 // Total angle is 270. (270 + 0 = 270)
1731 clippingRect.x = CLIPPING_RECT_Y;
1732 clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
1733 clippingRect.width = CLIPPING_RECT_HEIGHT;
1734 clippingRect.height = CLIPPING_RECT_WIDTH;
1736 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1737 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1738 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1739 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1741 // Check current orientations
1742 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1743 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1745 // It should be changed.
1746 DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION);
1747 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1752 int UtcDaliSceneScreenRotatedWithAngle270(void)
1754 tet_infoline("Ensure rotation of the screen is handled properly with Angle 270");
1756 TestApplication application(
1757 TestApplication::DEFAULT_SURFACE_WIDTH,
1758 TestApplication::DEFAULT_SURFACE_HEIGHT,
1759 TestApplication::DEFAULT_HORIZONTAL_DPI,
1760 TestApplication::DEFAULT_VERTICAL_DPI,
1764 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1766 std::vector<Rect<int>> damagedRects;
1767 Rect<int> clippingRect;
1768 application.SendNotification();
1769 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1771 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1773 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1774 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1776 Actor actor = CreateRenderableActor();
1777 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1778 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1779 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1780 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1781 application.GetScene().Add(actor);
1783 application.SendNotification();
1785 damagedRects.clear();
1786 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1787 TestApplication::DEFAULT_SURFACE_HEIGHT,
1790 // Check current surface orientation
1791 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1792 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1794 // It should not be changed yet.
1795 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1796 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1798 application.SendNotification();
1799 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1800 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1802 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1803 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1804 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1806 // It is recalculation for glScissor.
1807 // Because surface is rotated and glScissor is called with recalcurated value.
1808 // Total angle is 270. (0 + 270 = 270)
1809 clippingRect.x = CLIPPING_RECT_Y;
1810 clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
1811 clippingRect.width = CLIPPING_RECT_HEIGHT;
1812 clippingRect.height = CLIPPING_RECT_WIDTH;
1814 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1815 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1816 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1817 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1819 // Check current orientations
1820 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1821 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1823 // It should be changed.
1824 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1825 DALI_TEST_EQUALS(screenOrientation, 270, TEST_LOCATION);
1830 int UtcDaliSceneSurfaceAndScreenRotatedWithAngle270(void)
1832 tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 270");
1834 TestApplication application(
1835 TestApplication::DEFAULT_SURFACE_WIDTH,
1836 TestApplication::DEFAULT_SURFACE_HEIGHT,
1837 TestApplication::DEFAULT_HORIZONTAL_DPI,
1838 TestApplication::DEFAULT_VERTICAL_DPI,
1842 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1844 std::vector<Rect<int>> damagedRects;
1845 Rect<int> clippingRect;
1846 application.SendNotification();
1847 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1849 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1851 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1852 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1854 Actor actor = CreateRenderableActor();
1855 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1856 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1857 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1858 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1859 application.GetScene().Add(actor);
1861 application.SendNotification();
1863 damagedRects.clear();
1864 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1865 TestApplication::DEFAULT_SURFACE_HEIGHT,
1868 // Check current surface orientation
1869 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1870 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1872 // It should not be changed yet.
1873 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1874 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1876 application.SendNotification();
1877 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1878 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1880 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1881 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1882 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1884 // It is recalculation for glScissor.
1885 // Because surface is rotated and glScissor is called with recalcurated value.
1886 // Total angle is 180.(270 + 270 - 360 = 180)
1887 clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
1888 clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1889 clippingRect.width = CLIPPING_RECT_WIDTH;
1890 clippingRect.height = CLIPPING_RECT_HEIGHT;
1892 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1893 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1894 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1895 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1897 // Check current orientations
1898 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1899 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1901 // It should be changed.
1902 DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION);
1903 DALI_TEST_EQUALS(screenOrientation, 270, TEST_LOCATION);
1908 int UtcDaliSceneSetSurfaceRotationCompletedAcknowledgementWithAngle90(void)
1910 tet_infoline("Ensure to acknowledge for completing surface 90 angle rotaiton");
1912 TestApplication application(
1913 TestApplication::DEFAULT_SURFACE_WIDTH,
1914 TestApplication::DEFAULT_SURFACE_HEIGHT,
1915 TestApplication::DEFAULT_HORIZONTAL_DPI,
1916 TestApplication::DEFAULT_VERTICAL_DPI,
1920 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1922 std::vector<Rect<int>> damagedRects;
1923 Rect<int> clippingRect;
1924 application.SendNotification();
1925 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1927 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1928 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1930 Actor actor = CreateRenderableActor();
1931 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1932 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1933 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1934 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1935 application.GetScene().Add(actor);
1937 application.SendNotification();
1939 damagedRects.clear();
1940 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1941 TestApplication::DEFAULT_SURFACE_HEIGHT,
1944 // Check current surface orientation
1945 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1946 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1948 // It should not be changed yet.
1949 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1950 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1952 application.GetScene().SetRotationCompletedAcknowledgement();
1954 application.SendNotification();
1955 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1956 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1958 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1959 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1960 application.RenderWithPartialUpdate(damagedRects, clippingRect);
1962 // It is recalculation for glScissor.
1963 // Because surface is rotated and glScissor is called with recalcurated value.
1964 clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1965 clippingRect.y = CLIPPING_RECT_X;
1966 clippingRect.width = CLIPPING_RECT_HEIGHT;
1967 clippingRect.height = CLIPPING_RECT_WIDTH;
1969 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1970 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1971 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1972 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1974 // Check current orientations
1975 orientation = application.GetScene().GetCurrentSurfaceOrientation();
1976 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
1978 // It should be changed.
1979 DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION);
1980 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
1982 bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet();
1983 DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION);
1988 int UtcDaliSceneSetScreenRotationCompletedAcknowledgementWithAngle90(void)
1990 tet_infoline("Ensure to acknowledge for completing screen 90 angle rotaiton");
1992 TestApplication application(
1993 TestApplication::DEFAULT_SURFACE_WIDTH,
1994 TestApplication::DEFAULT_SURFACE_HEIGHT,
1995 TestApplication::DEFAULT_HORIZONTAL_DPI,
1996 TestApplication::DEFAULT_VERTICAL_DPI,
2000 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
2002 std::vector<Rect<int>> damagedRects;
2003 Rect<int> clippingRect;
2004 application.SendNotification();
2005 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
2007 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
2008 application.RenderWithPartialUpdate(damagedRects, clippingRect);
2010 Actor actor = CreateRenderableActor();
2011 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2012 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
2013 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
2014 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
2015 application.GetScene().Add(actor);
2017 application.SendNotification();
2019 damagedRects.clear();
2020 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
2021 TestApplication::DEFAULT_SURFACE_HEIGHT,
2024 // Check current surface orientation
2025 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
2026 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
2028 // It should not be changed yet.
2029 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
2030 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
2032 application.GetScene().SetRotationCompletedAcknowledgement();
2034 application.SendNotification();
2035 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
2036 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
2038 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
2039 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
2040 application.RenderWithPartialUpdate(damagedRects, clippingRect);
2042 // It is recalculation for glScissor.
2043 // Because surface is rotated and glScissor is called with recalcurated value.
2044 clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
2045 clippingRect.y = CLIPPING_RECT_X;
2046 clippingRect.width = CLIPPING_RECT_HEIGHT;
2047 clippingRect.height = CLIPPING_RECT_WIDTH;
2049 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
2050 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
2051 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
2052 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
2054 // Check current orientations
2055 orientation = application.GetScene().GetCurrentSurfaceOrientation();
2056 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
2058 // It should be changed.
2059 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
2060 DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION);
2062 bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet();
2063 DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION);
2068 int UtcDaliSceneSetSurfaceAndScreenRotationCompletedAcknowledgementWithAngle90(void)
2070 tet_infoline("Ensure to acknowledge for completing surface and screen 90 angle rotaiton");
2072 TestApplication application(
2073 TestApplication::DEFAULT_SURFACE_WIDTH,
2074 TestApplication::DEFAULT_SURFACE_HEIGHT,
2075 TestApplication::DEFAULT_HORIZONTAL_DPI,
2076 TestApplication::DEFAULT_VERTICAL_DPI,
2080 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
2082 std::vector<Rect<int>> damagedRects;
2083 Rect<int> clippingRect;
2084 application.SendNotification();
2085 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
2087 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
2088 application.RenderWithPartialUpdate(damagedRects, clippingRect);
2090 Actor actor = CreateRenderableActor();
2091 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2092 actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
2093 actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
2094 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
2095 application.GetScene().Add(actor);
2097 application.SendNotification();
2099 damagedRects.clear();
2100 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
2101 TestApplication::DEFAULT_SURFACE_HEIGHT,
2104 // Check current surface orientation
2105 int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
2106 int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation();
2108 // It should not be changed yet.
2109 DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
2110 DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION);
2112 application.GetScene().SetRotationCompletedAcknowledgement();
2114 application.SendNotification();
2115 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
2116 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
2118 clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
2119 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
2120 application.RenderWithPartialUpdate(damagedRects, clippingRect);
2122 // It is recalculation for glScissor.
2123 // Because surface is rotated and glScissor is called with recalcurated value.
2124 clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
2125 clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
2126 clippingRect.width = CLIPPING_RECT_WIDTH;
2127 clippingRect.height = CLIPPING_RECT_HEIGHT;
2129 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
2130 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
2131 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
2132 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
2134 // Check current orientations
2135 orientation = application.GetScene().GetCurrentSurfaceOrientation();
2136 screenOrientation = application.GetScene().GetCurrentScreenOrientation();
2138 // It should be changed.
2139 DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION);
2140 DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION);
2142 bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet();
2143 DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION);
2148 int UtcDaliSceneSurfaceRotatedPartialUpdate(void)
2150 tet_infoline("Ensure rotation of the surface and partial update are handled properly");
2152 TestApplication application(
2153 TestApplication::DEFAULT_SURFACE_WIDTH,
2154 TestApplication::DEFAULT_SURFACE_HEIGHT,
2155 TestApplication::DEFAULT_HORIZONTAL_DPI,
2156 TestApplication::DEFAULT_VERTICAL_DPI,
2160 const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
2162 std::vector<Rect<int>> damagedRects;
2163 Rect<int> clippingRect;
2164 application.SendNotification();
2165 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
2167 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
2169 clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
2170 application.RenderWithPartialUpdate(damagedRects, clippingRect);
2172 Actor actor = CreateRenderableActor();
2173 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
2174 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2175 actor.SetProperty(Actor::Property::SIZE, Vector3(32.0f, 32.0f, 0.0f));
2176 actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
2177 application.GetScene().Add(actor);
2179 application.SendNotification();
2180 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
2182 clippingRect = Rect<int>(224, 384, 48, 48); // in screen coordinates
2183 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
2184 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
2186 application.RenderWithPartialUpdate(damagedRects, clippingRect);
2188 DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
2189 DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
2190 DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
2191 DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
2193 damagedRects.clear();
2194 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
2195 application.RenderWithPartialUpdate(damagedRects, clippingRect);
2197 damagedRects.clear();
2198 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
2199 application.RenderWithPartialUpdate(damagedRects, clippingRect);
2201 // Ensure the damaged rect is empty
2202 DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
2205 application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_HEIGHT,
2206 TestApplication::DEFAULT_SURFACE_WIDTH,
2209 damagedRects.clear();
2211 application.SendNotification();
2212 application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
2214 clippingRect = Rect<int>(224, 224, 208, 208); // in screen coordinates, merged value with the previous rect
2215 DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
2216 DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
2218 application.RenderWithPartialUpdate(damagedRects, clippingRect);
2223 int UtcDaliSceneKeyEventGeneratedSignalP(void)
2225 TestApplication application;
2226 Dali::Integration::Scene scene = application.GetScene();
2228 KeyEventGeneratedSignalData data;
2229 KeyEventGeneratedReceivedFunctor functor(data);
2230 scene.KeyEventGeneratedSignal().Connect(&application, functor);
2232 Integration::KeyEvent event("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
2233 application.ProcessEvent(event);
2235 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2236 DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
2237 DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
2238 DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
2239 DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
2243 Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
2244 application.ProcessEvent(event2);
2246 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2247 DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
2248 DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
2249 DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
2250 DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
2254 Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
2255 application.ProcessEvent(event3);
2257 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2258 DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
2259 DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
2260 DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
2261 DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
2265 Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
2266 application.ProcessEvent(event4);
2268 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2269 DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
2270 DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
2271 DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
2272 DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
2276 int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void)
2278 tet_infoline("Ensure we keep background color when the scene surface is replaced ");
2280 TestApplication application;
2282 // Create a new scene and set the background color of the main scene
2283 auto defaultScene = application.GetScene();
2284 defaultScene.SetBackgroundColor(Color::BLUE);
2286 // Need to create a renderable as we don't start rendering until we have at least one
2287 // We don't need to add this to any scene
2288 auto actor = CreateRenderableActor();
2290 auto& glAbstraction = application.GetGlAbstraction();
2291 auto clearCountBefore = glAbstraction.GetClearCountCalled();
2293 application.SendNotification();
2294 application.Render();
2296 DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION);
2297 DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
2299 defaultScene.SurfaceReplaced();
2301 application.SendNotification();
2302 application.Render();
2304 DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION);
2305 DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
2307 // Check when the main render task viewport is set the clear color is clipped using scissors
2308 TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
2309 TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
2310 scissorTrace.Enable(true);
2311 enabledDisableTrace.Enable(true);
2313 defaultScene.GetRenderTaskList().GetTask(0).SetViewport(Viewport(0.0f, 0.0f, 100.0f, 100.0f));
2315 application.SendNotification();
2316 application.Render();
2318 // Check scissor test was enabled.
2319 std::ostringstream scissor;
2320 scissor << std::hex << GL_SCISSOR_TEST;
2321 DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
2323 // Check the scissor was set, and the coordinates are correct.
2324 DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", "0, 700, 100, 100"));
2326 DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION);
2327 DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
2329 scissorTrace.Enable(false);
2330 scissorTrace.Reset();
2332 enabledDisableTrace.Enable(false);
2333 enabledDisableTrace.Reset();
2338 int UtcDaliSceneEnsureRenderTargetRecreated(void)
2340 tet_infoline("Ensure render target is re-created when surface replaced ");
2342 TestApplication application;
2344 // Create a new scene and set the background color of the main scene
2345 auto defaultScene = application.GetScene();
2346 defaultScene.SetBackgroundColor(Color::BLUE);
2348 auto actor = CreateRenderableActor();
2349 defaultScene.Add(actor);
2351 auto& graphicsController = application.GetGraphicsController();
2353 application.SendNotification();
2354 application.Render();
2356 TraceCallStack& graphicsCallStack = graphicsController.mCallStack;
2357 TraceCallStack::NamedParams empty{};
2358 const TraceCallStack::NamedParams* matching = graphicsCallStack.FindLastMatch("PresentRenderTarget", empty);
2359 DALI_TEST_CHECK(matching != nullptr);
2361 graphicsCallStack.Reset();
2364 Graphics::RenderTargetCreateInfo createInfo{};
2365 createInfo.SetSurface(&fakeSurface1).SetExtent(Graphics::Extent2D{480u, 800u});
2366 defaultScene.SetSurfaceRenderTarget(createInfo);
2368 application.SendNotification();
2369 application.Render();
2371 TraceCallStack::NamedParams query1;
2372 query1["surface"] << std::hex << &fakeSurface1;
2373 const TraceCallStack::NamedParams* matching2 = graphicsCallStack.FindLastMatch("CreateRenderTarget", query1);
2374 DALI_TEST_CHECK(matching2 != nullptr);
2376 const TraceCallStack::NamedParams* matching3 = graphicsCallStack.FindLastMatch("PresentRenderTarget", empty);
2377 DALI_TEST_CHECK(matching3 != nullptr);
2378 DALI_TEST_EQUALS((*matching3)["surface"].str(), query1["surface"].str(), TEST_LOCATION);
2383 int UtcDaliSceneEmptySceneRendering(void)
2385 tet_infoline("Ensure not rendering before a Renderer is added");
2387 TestApplication application;
2388 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2390 // Render without any renderer
2391 application.SendNotification();
2392 application.Render();
2394 // Check the clear count and the render status
2395 DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 0, TEST_LOCATION);
2396 DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), false, TEST_LOCATION);
2399 Geometry geometry = CreateQuadGeometry();
2400 Shader shader = CreateShader();
2401 Renderer renderer = Renderer::New(geometry, shader);
2403 // Render before adding renderer
2404 application.SendNotification();
2405 application.Render();
2407 // Check the clear count and the render status
2408 DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 0, TEST_LOCATION);
2409 DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), false, TEST_LOCATION);
2411 Actor actor = Actor::New();
2412 actor.AddRenderer(renderer);
2414 actor.SetProperty(Actor::Property::SIZE, Vector2(400, 400));
2415 application.GetScene().Add(actor);
2418 application.SendNotification();
2419 application.Render();
2421 // Check the clear count and the render status
2422 DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 1, TEST_LOCATION);
2423 DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), true, TEST_LOCATION);
2425 // Remove the Renderer
2426 application.GetScene().Remove(actor);
2431 application.SendNotification();
2432 application.Render();
2434 // Check the clear count and the render status
2435 DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 2, TEST_LOCATION); // Should be cleared
2436 DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), true, TEST_LOCATION);
2441 int UtcDaliSceneFrameRenderedPresentedCallback(void)
2443 tet_infoline("UtcDaliSceneFrameRenderedCallback");
2445 TestApplication application;
2448 Geometry geometry = CreateQuadGeometry();
2449 Shader shader = CreateShader();
2450 Renderer renderer = Renderer::New(geometry, shader);
2452 Actor actor = Actor::New();
2453 actor.AddRenderer(renderer);
2454 application.GetScene().Add(actor);
2456 Dali::Integration::Scene scene = application.GetScene();
2459 scene.AddFrameRenderedCallback(std::unique_ptr<CallbackBase>(MakeCallback(&FrameCallback)), frameId);
2460 scene.AddFramePresentedCallback(std::unique_ptr<CallbackBase>(MakeCallback(&FrameCallback)), frameId);
2463 application.SendNotification();
2464 application.Render();
2466 Dali::Integration::Scene::FrameCallbackContainer callbackContainer;
2467 scene.GetFrameRenderedCallback(callbackContainer);
2469 DALI_TEST_EQUALS(callbackContainer.size(), 1, TEST_LOCATION);
2470 DALI_TEST_EQUALS(callbackContainer[0].second, frameId, TEST_LOCATION);
2472 callbackContainer.clear();
2474 scene.GetFramePresentedCallback(callbackContainer);
2476 DALI_TEST_EQUALS(callbackContainer.size(), 1, TEST_LOCATION);
2477 DALI_TEST_EQUALS(callbackContainer[0].second, frameId, TEST_LOCATION);
2482 int UtcDaliSceneWheelEventGeneratedSignalP(void)
2484 TestApplication application;
2485 Dali::Integration::Scene scene = application.GetScene();
2487 WheelEventGeneratedSignalData data;
2488 WheelEventGeneratedReceivedFunctor functor(data);
2489 scene.WheelEventGeneratedSignal().Connect(&application, functor);
2491 Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
2492 application.ProcessEvent(event);
2494 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2495 DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event.type) == data.receivedWheelEvent.GetType());
2496 DALI_TEST_CHECK(event.direction == data.receivedWheelEvent.GetDirection());
2497 DALI_TEST_CHECK(event.modifiers == data.receivedWheelEvent.GetModifiers());
2498 DALI_TEST_CHECK(event.point == data.receivedWheelEvent.GetPoint());
2499 DALI_TEST_CHECK(event.delta == data.receivedWheelEvent.GetDelta());
2500 DALI_TEST_CHECK(event.timeStamp == data.receivedWheelEvent.GetTime());
2504 Integration::WheelEvent event2(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1000u);
2505 application.ProcessEvent(event2);
2507 DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
2508 DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event2.type) == data.receivedWheelEvent.GetType());
2509 DALI_TEST_CHECK(event2.direction == data.receivedWheelEvent.GetDirection());
2510 DALI_TEST_CHECK(event2.modifiers == data.receivedWheelEvent.GetModifiers());
2511 DALI_TEST_CHECK(event2.point == data.receivedWheelEvent.GetPoint());
2512 DALI_TEST_CHECK(event2.delta == data.receivedWheelEvent.GetDelta());
2513 DALI_TEST_CHECK(event2.timeStamp == data.receivedWheelEvent.GetTime());
2517 int UtcDaliSceneSignalInterceptKeyEventP(void)
2519 TestApplication application;
2520 Dali::Integration::Scene scene = application.GetScene();
2522 KeyEventSignalData data;
2523 KeyEventReceivedFunctor functor(data);
2524 scene.KeyEventSignal().Connect(&application, functor);
2526 KeyEventGeneratedSignalData interceptData;
2527 KeyEventGeneratedReceivedFunctor interceptFunctor(interceptData);
2528 scene.InterceptKeyEventSignal().Connect(&application, interceptFunctor);
2530 Integration::KeyEvent event("i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
2531 application.ProcessEvent(event);
2533 DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION);
2534 DALI_TEST_CHECK(event.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier());
2535 DALI_TEST_CHECK(event.keyName == interceptData.receivedKeyEvent.GetKeyName());
2536 DALI_TEST_CHECK(event.keyString == interceptData.receivedKeyEvent.GetKeyString());
2537 DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(interceptData.receivedKeyEvent.GetState()));
2538 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2541 interceptData.Reset();
2543 Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
2544 application.ProcessEvent(event2);
2546 DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION);
2547 DALI_TEST_CHECK(event2.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier());
2548 DALI_TEST_CHECK(event2.keyName == interceptData.receivedKeyEvent.GetKeyName());
2549 DALI_TEST_CHECK(event2.keyString == interceptData.receivedKeyEvent.GetKeyString());
2550 DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(interceptData.receivedKeyEvent.GetState()));
2551 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2554 interceptData.Reset();
2556 Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
2557 application.ProcessEvent(event3);
2559 DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION);
2560 DALI_TEST_CHECK(event3.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier());
2561 DALI_TEST_CHECK(event3.keyName == interceptData.receivedKeyEvent.GetKeyName());
2562 DALI_TEST_CHECK(event3.keyString == interceptData.receivedKeyEvent.GetKeyString());
2563 DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(interceptData.receivedKeyEvent.GetState()));
2564 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2567 interceptData.Reset();
2569 Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
2570 application.ProcessEvent(event4);
2572 DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION);
2573 DALI_TEST_CHECK(event4.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier());
2574 DALI_TEST_CHECK(event4.keyName == interceptData.receivedKeyEvent.GetKeyName());
2575 DALI_TEST_CHECK(event4.keyString == interceptData.receivedKeyEvent.GetKeyString());
2576 DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(interceptData.receivedKeyEvent.GetState()));
2577 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2581 int UtcDaliSceneSignalInterceptKeyEventN(void)
2583 TestApplication application;
2584 Dali::Integration::Scene scene = application.GetScene();
2586 KeyEventGeneratedSignalData data;
2587 KeyEventGeneratedReceivedFunctor functor(data);
2588 scene.InterceptKeyEventSignal().Connect(&application, functor);
2590 // Check that a non-pressed key events data is not modified.
2591 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
2596 int UtcDaliSceneGetOverlayLayer(void)
2598 TestApplication application;
2599 tet_infoline("Testing Dali::Integration::Scene::GetOverlayLayer");
2601 Dali::Integration::Scene scene = application.GetScene();
2603 // Check we get a valid instance.
2604 RenderTaskList tasks = scene.GetRenderTaskList();
2606 // There should be 1 task by default.
2607 DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION);
2608 RenderTask defaultTask = tasks.GetTask(0u);
2609 DALI_TEST_EQUALS(scene.GetRootLayer(), defaultTask.GetSourceActor(), TEST_LOCATION);
2611 Layer layer = scene.GetOverlayLayer();
2612 // There should be 2 task by default.
2613 DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION);
2614 RenderTask overlayTask = tasks.GetTask(1u);
2615 DALI_TEST_EQUALS(overlayTask, tasks.GetOverlayTask(), TEST_LOCATION);
2616 DALI_TEST_CHECK(scene.GetRootLayer() != overlayTask.GetSourceActor());
2617 DALI_TEST_CHECK(overlayTask != defaultTask);
2618 DALI_TEST_EQUALS(overlayTask.GetClearEnabled(), false, TEST_LOCATION);
2619 DALI_TEST_EQUALS(overlayTask.IsExclusive(), true, TEST_LOCATION);
2621 // If new render task is created, the last task is overlayTask
2622 RenderTask newTask = scene.GetRenderTaskList().CreateTask();
2623 DALI_TEST_EQUALS(tasks.GetTaskCount(), 3u, TEST_LOCATION);
2624 DALI_TEST_EQUALS(newTask, tasks.GetTask(1u), TEST_LOCATION);
2625 DALI_TEST_EQUALS(overlayTask, tasks.GetTask(2u), TEST_LOCATION);
2628 application.SendNotification();
2629 application.Render();
2631 tasks.RemoveTask(overlayTask);
2632 DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION);
2633 DALI_TEST_EQUALS(tasks.GetTask(0u), defaultTask, TEST_LOCATION);
2634 DALI_TEST_EQUALS(tasks.GetTask(1u), newTask, TEST_LOCATION);
2636 // Check overlay task removed well
2637 DALI_TEST_EQUALS(nullptr, tasks.GetOverlayTask(), TEST_LOCATION);
2639 application.SendNotification();
2640 application.Render();
2645 int UtcDaliSceneSurfaceResizedWithOverlayLayer(void)
2647 tet_infoline("Ensure resizing of the surface is handled properly");
2649 TestApplication application;
2651 auto scene = application.GetScene();
2652 DALI_TEST_CHECK(scene);
2654 const RenderTaskList& tasks = scene.GetRenderTaskList();
2655 DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION);
2656 RenderTask defaultTask = tasks.GetTask(0u);
2657 DALI_TEST_EQUALS(scene.GetRootLayer(), defaultTask.GetSourceActor(), TEST_LOCATION);
2659 // Ensure stage size matches the scene size
2660 auto stage = Stage::GetCurrent();
2661 Vector2 sceneSize = stage.GetSize();
2662 Viewport sceneViewport(0, 0, sceneSize.x, sceneSize.y);
2663 DALI_TEST_EQUALS(stage.GetSize(), scene.GetSize(), TEST_LOCATION);
2664 Viewport defaultViewport = defaultTask.GetViewport();
2665 DALI_TEST_EQUALS(defaultViewport, sceneViewport, TEST_LOCATION);
2667 Layer layer = scene.GetOverlayLayer();
2668 // There should be 2 task by default.
2669 DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION);
2670 RenderTask overlayTask = tasks.GetTask(1u);
2671 Viewport overlayViewport = overlayTask.GetViewport();
2672 DALI_TEST_EQUALS(defaultViewport, overlayViewport, TEST_LOCATION);
2675 Vector2 newSize(1000.0f, 2000.0f);
2676 DALI_TEST_CHECK(stage.GetSize() != newSize);
2677 scene.SurfaceResized(newSize.width, newSize.height);
2678 Viewport newViewport(0, 0, newSize.x, newSize.y);
2679 DALI_TEST_EQUALS(newViewport, defaultTask.GetViewport(), TEST_LOCATION);
2680 DALI_TEST_EQUALS(newViewport, overlayTask.GetViewport(), TEST_LOCATION);