X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-Scene.cpp;h=959e5ee548053c7695b99addb8ba63dbe156e224;hb=eacc080fe975c523d722dd17c044652317ddd6e8;hp=b4c87dbf9cb4756f4104beb571a9faee15edc8fa;hpb=fbec186ca2fd1ed8f1b637e2aa498ba15e70dcc6;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/automated-tests/src/dali/utc-Dali-Scene.cpp b/automated-tests/src/dali/utc-Dali-Scene.cpp index b4c87db..959e5ee 100644 --- a/automated-tests/src/dali/utc-Dali-Scene.cpp +++ b/automated-tests/src/dali/utc-Dali-Scene.cpp @@ -1016,7 +1016,7 @@ int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void) DALI_TEST_EQUALS(surfaceResized, true, TEST_LOCATION); // Check that the viewport is handled properly - DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams)); + DALI_TEST_CHECK(callStack.FindIndexFromMethodAndParams("Viewport", viewportParams) >= 0); // Check current surface rect newSurfaceRect = defaultScene.GetCurrentSurfaceRect(); @@ -1116,34 +1116,642 @@ int UtcDaliSceneSurfaceResizedAdditionalScene(void) TestApplication application; Vector2 originalSurfaceSize(500.0f, 1000.0f); - auto scene = Integration::Scene::New(Size(originalSurfaceSize.width, originalSurfaceSize.height)); + auto scene = Integration::Scene::New(Size(originalSurfaceSize.width, originalSurfaceSize.height)); + + // Ensure stage size does NOT match the surface size + auto stage = Stage::GetCurrent(); + const auto stageSize = stage.GetSize(); + DALI_TEST_CHECK(stageSize != originalSurfaceSize); + DALI_TEST_EQUALS(originalSurfaceSize, scene.GetSize(), TEST_LOCATION); + + // Resize the surface and inform the scene accordingly + Vector2 newSize(1000.0f, 2000.0f); + DALI_TEST_CHECK(stage.GetSize() != newSize); + scene.SurfaceResized(newSize.width, newSize.height); + + // Ensure the stage hasn't been resized + DALI_TEST_EQUALS(stage.GetSize(), stageSize, TEST_LOCATION); + DALI_TEST_EQUALS(scene.GetSize(), newSize, TEST_LOCATION); + + END_TEST; +} + +#define CLIPPING_RECT_X (16) +#define CLIPPING_RECT_Y (768) +#define CLIPPING_RECT_WIDTH (32) +#define CLIPPING_RECT_HEIGHT (32) + +int UtcDaliSceneSurfaceRotatedWithAngle0(void) +{ + tet_infoline("Ensure rotation of the surface is handled properly with Angle 0"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + // consume the orientating changing flag by first rendering + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 0, 0); + + // Check current orientations + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceRotatedWithAngle90(void) +{ + tet_infoline("Ensure rotation of the surface is handled properly with Angle 90"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 90, 0); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 90, (90 + 0 = 90) + clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.y = CLIPPING_RECT_X; + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneScreenRotatedWithAngle90(void) +{ + tet_infoline("Ensure rotation of the screen is handled properly with Angle 90"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 0, 90); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 90, (0 + 90 = 90) + clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.y = CLIPPING_RECT_X; + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceAndScreenRotatedWithAngle90(void) +{ + tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 90"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 90, 90); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 180.(90 + 90 = 180) + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceRotatedWithAngle180(void) +{ + tet_infoline("Ensure rotation of the surface is handled properly with Angle 180"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 180, 0); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneScreenRotatedWithAngle180(void) +{ + tet_infoline("Ensure rotation of the screen is handled properly with Angle 180"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 0, 180); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 180, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceAndScreenRotatedWithAngle180(void) +{ + tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 180"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + // consume the orientating changing flag by first rendering + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 180, 180); + + // Check current orientations + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 180, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceRotatedWithAngle270(void) +{ + tet_infoline("Ensure rotation of the surface is handled properly with Angle 270"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 270, 0); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 270. (270 + 0 = 270) + clippingRect.x = CLIPPING_RECT_Y; + clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; - // Ensure stage size does NOT match the surface size - auto stage = Stage::GetCurrent(); - const auto stageSize = stage.GetSize(); - DALI_TEST_CHECK(stageSize != originalSurfaceSize); - DALI_TEST_EQUALS(originalSurfaceSize, scene.GetSize(), TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Resize the surface and inform the scene accordingly - Vector2 newSize(1000.0f, 2000.0f); - DALI_TEST_CHECK(stage.GetSize() != newSize); - scene.SurfaceResized(newSize.width, newSize.height); + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); - // Ensure the stage hasn't been resized - DALI_TEST_EQUALS(stage.GetSize(), stageSize, TEST_LOCATION); - DALI_TEST_EQUALS(scene.GetSize(), newSize, TEST_LOCATION); + // It should be changed. + DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); END_TEST; } -#define CLIPPING_RECT_X (16) -#define CLIPPING_RECT_Y (768) -#define CLIPPING_RECT_WIDTH (32) -#define CLIPPING_RECT_HEIGHT (32) - -int UtcDaliSceneSurfaceRotatedWithAngle0(void) +int UtcDaliSceneScreenRotatedWithAngle270(void) { - tet_infoline("Ensure rotation of the surface is handled properly with Angle 0"); + tet_infoline("Ensure rotation of the screen is handled properly with Angle 270"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1177,13 +1785,15 @@ int UtcDaliSceneSurfaceRotatedWithAngle0(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 0); + 0, 270); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should not be changed yet. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); @@ -1193,23 +1803,33 @@ int UtcDaliSceneSurfaceRotatedWithAngle0(void) DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); application.RenderWithPartialUpdate(damagedRects, clippingRect); + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 270. (0 + 270 = 270) + clippingRect.x = CLIPPING_RECT_Y; + clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Check current surface orientation + // Check current orientations orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 270, TEST_LOCATION); END_TEST; } -int UtcDaliSceneSurfaceRotatedWithAngle90(void) +int UtcDaliSceneSurfaceAndScreenRotatedWithAngle270(void) { - tet_infoline("Ensure rotation of the surface is handled properly with Angle 90"); + tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 270"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1243,13 +1863,15 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 90); + 270, 270); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should not be changed yet. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); @@ -1261,28 +1883,31 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. - clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); - clippingRect.y = CLIPPING_RECT_X; - clippingRect.width = CLIPPING_RECT_HEIGHT; - clippingRect.height = CLIPPING_RECT_WIDTH; + // Total angle is 180.(270 + 270 - 360 = 180) + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Check current surface orientation + // Check current orientations orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. - DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 270, TEST_LOCATION); END_TEST; } -int UtcDaliSceneSurfaceRotatedWithAngle180(void) +int UtcDaliSceneSetSurfaceRotationCompletedAcknowledgementWithAngle90(void) { - tet_infoline("Ensure rotation of the surface is handled properly with Angle 180"); + tet_infoline("Ensure to acknowledge for completing surface 90 angle rotaiton"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1300,8 +1925,6 @@ int UtcDaliSceneSurfaceRotatedWithAngle180(void) application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); - - clippingRect = TestApplication::DEFAULT_SURFACE_RECT; application.RenderWithPartialUpdate(damagedRects, clippingRect); Actor actor = CreateRenderableActor(); @@ -1316,13 +1939,17 @@ int UtcDaliSceneSurfaceRotatedWithAngle180(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 180); + 90, 0); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should not be changed yet. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.GetScene().SetRotationCompletedAcknowledgement(); application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); @@ -1334,28 +1961,33 @@ int UtcDaliSceneSurfaceRotatedWithAngle180(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. - clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); - clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); - clippingRect.width = CLIPPING_RECT_WIDTH; - clippingRect.height = CLIPPING_RECT_HEIGHT; + clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.y = CLIPPING_RECT_X; + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Check current surface orientation + // Check current orientations orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. - DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION); + DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); + DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); END_TEST; } -int UtcDaliSceneSurfaceRotatedWithAngle270(void) +int UtcDaliSceneSetScreenRotationCompletedAcknowledgementWithAngle90(void) { - tet_infoline("Ensure rotation of the surface is handled properly with Angle 270"); + tet_infoline("Ensure to acknowledge for completing screen 90 angle rotaiton"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1373,8 +2005,6 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); - - clippingRect = TestApplication::DEFAULT_SURFACE_RECT; application.RenderWithPartialUpdate(damagedRects, clippingRect); Actor actor = CreateRenderableActor(); @@ -1389,13 +2019,17 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 270); + 0, 90); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should not be changed yet. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.GetScene().SetRotationCompletedAcknowledgement(); application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); @@ -1407,8 +2041,8 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. - clippingRect.x = CLIPPING_RECT_Y; - clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.y = CLIPPING_RECT_X; clippingRect.width = CLIPPING_RECT_HEIGHT; clippingRect.height = CLIPPING_RECT_WIDTH; @@ -1417,18 +2051,23 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Check current surface orientation + // Check current orientations orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. - DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); + + bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); + DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); END_TEST; } -int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) +int UtcDaliSceneSetSurfaceAndScreenRotationCompletedAcknowledgementWithAngle90(void) { - tet_infoline("Ensure to acknowledge for completing surface 90 angle rotaiton"); + tet_infoline("Ensure to acknowledge for completing surface and screen 90 angle rotaiton"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1460,13 +2099,15 @@ int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 90); + 90, 90); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should not be changed yet. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); application.GetScene().SetRotationCompletedAcknowledgement(); @@ -1480,21 +2121,23 @@ int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. - clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); - clippingRect.y = CLIPPING_RECT_X; - clippingRect.width = CLIPPING_RECT_HEIGHT; - clippingRect.height = CLIPPING_RECT_WIDTH; + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Check current surface orientation + // Check current orientations orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); @@ -1502,6 +2145,81 @@ int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) END_TEST; } +int UtcDaliSceneSurfaceRotatedPartialUpdate(void) +{ + tet_infoline("Ensure rotation of the surface and partial update are handled properly"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + actor.SetProperty(Actor::Property::SIZE, Vector3(32.0f, 32.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + clippingRect = Rect(224, 384, 48, 48); // in screen coordinates + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + damagedRects.clear(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + damagedRects.clear(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // Ensure the damaged rect is empty + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + // Rotate surface + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_SURFACE_WIDTH, + 90, 0); + + damagedRects.clear(); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + clippingRect = Rect(224, 224, 208, 208); // in screen coordinates, merged value with the previous rect + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + END_TEST; +} + int UtcDaliSceneKeyEventGeneratedSignalP(void) { TestApplication application; @@ -1795,3 +2513,165 @@ int UtcDaliSceneWheelEventGeneratedSignalP(void) DALI_TEST_CHECK(event2.timeStamp == data.receivedWheelEvent.GetTime()); END_TEST; } + +int UtcDaliSceneSignalInterceptKeyEventP(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + KeyEventSignalData data; + KeyEventReceivedFunctor functor(data); + scene.KeyEventSignal().Connect(&application, functor); + + KeyEventGeneratedSignalData interceptData; + KeyEventGeneratedReceivedFunctor interceptFunctor(interceptData); + scene.InterceptKeyEventSignal().Connect(&application, interceptFunctor); + + Integration::KeyEvent event("i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + data.Reset(); + interceptData.Reset(); + + Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event2); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event2.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event2.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event2.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event2.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + data.Reset(); + interceptData.Reset(); + + Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event3); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event3.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event3.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event3.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event3.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + data.Reset(); + interceptData.Reset(); + + Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event4); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event4.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event4.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event4.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event4.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + END_TEST; +} + +int UtcDaliSceneSignalInterceptKeyEventN(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + KeyEventGeneratedSignalData data; + KeyEventGeneratedReceivedFunctor functor(data); + scene.InterceptKeyEventSignal().Connect(&application, functor); + + // Check that a non-pressed key events data is not modified. + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneGetOverlayLayer(void) +{ + TestApplication application; + tet_infoline("Testing Dali::Integration::Scene::GetOverlayLayer"); + + Dali::Integration::Scene scene = application.GetScene(); + + // Check we get a valid instance. + RenderTaskList tasks = scene.GetRenderTaskList(); + + // There should be 1 task by default. + DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION); + RenderTask defaultTask = tasks.GetTask(0u); + DALI_TEST_EQUALS(scene.GetRootLayer(), defaultTask.GetSourceActor(), TEST_LOCATION); + + Layer layer = scene.GetOverlayLayer(); + // There should be 2 task by default. + DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION); + RenderTask overlayTask = tasks.GetTask(1u); + DALI_TEST_EQUALS(overlayTask, tasks.GetOverlayTask(), TEST_LOCATION); + DALI_TEST_CHECK(scene.GetRootLayer() != overlayTask.GetSourceActor()); + DALI_TEST_CHECK(overlayTask != defaultTask); + DALI_TEST_EQUALS(overlayTask.GetClearEnabled(), false, TEST_LOCATION); + DALI_TEST_EQUALS(overlayTask.IsExclusive(), true, TEST_LOCATION); + + // If new render task is created, the last task is overlayTask + RenderTask newTask = scene.GetRenderTaskList().CreateTask(); + DALI_TEST_EQUALS(tasks.GetTaskCount(), 3u, TEST_LOCATION); + DALI_TEST_EQUALS(newTask, tasks.GetTask(1u), TEST_LOCATION); + DALI_TEST_EQUALS(overlayTask, tasks.GetTask(2u), TEST_LOCATION); + + // Render + application.SendNotification(); + application.Render(); + + tasks.RemoveTask(overlayTask); + DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION); + DALI_TEST_EQUALS(tasks.GetTask(0u), defaultTask, TEST_LOCATION); + DALI_TEST_EQUALS(tasks.GetTask(1u), newTask, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceResizedWithOverlayLayer(void) +{ + tet_infoline("Ensure resizing of the surface is handled properly"); + + TestApplication application; + + auto scene = application.GetScene(); + DALI_TEST_CHECK(scene); + + const RenderTaskList& tasks = scene.GetRenderTaskList(); + DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION); + RenderTask defaultTask = tasks.GetTask(0u); + DALI_TEST_EQUALS(scene.GetRootLayer(), defaultTask.GetSourceActor(), TEST_LOCATION); + + // Ensure stage size matches the scene size + auto stage = Stage::GetCurrent(); + Vector2 sceneSize = stage.GetSize(); + Viewport sceneViewport(0, 0, sceneSize.x, sceneSize.y); + DALI_TEST_EQUALS(stage.GetSize(), scene.GetSize(), TEST_LOCATION); + Viewport defaultViewport = defaultTask.GetViewport(); + DALI_TEST_EQUALS(defaultViewport, sceneViewport, TEST_LOCATION); + + Layer layer = scene.GetOverlayLayer(); + // There should be 2 task by default. + DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION); + RenderTask overlayTask = tasks.GetTask(1u); + Viewport overlayViewport = defaultTask.GetViewport(); + DALI_TEST_EQUALS(defaultViewport, overlayViewport, TEST_LOCATION); + + // Resize the scene + Vector2 newSize(1000.0f, 2000.0f); + DALI_TEST_CHECK(stage.GetSize() != newSize); + scene.SurfaceResized(newSize.width, newSize.height); + Viewport newViewport(0, 0, newSize.x, newSize.y); + DALI_TEST_EQUALS(newViewport, defaultTask.GetViewport(), TEST_LOCATION); + DALI_TEST_EQUALS(newViewport, defaultTask.GetViewport(), TEST_LOCATION); + + END_TEST; +}