From 6c5c060ed2522dd0df1de807296079c9a18c1ee5 Mon Sep 17 00:00:00 2001 From: Wonsik Jung Date: Tue, 3 Jan 2023 12:09:13 +0900 Subject: [PATCH] Fix the screen rotation issue Fix the screen rotation issue in FHub Device. When glViewport/glScissor is set, the screen rotation should be considered. Change-Id: I660545a3b3b0fa8e5464dfb613a3d983be2e04b7 --- automated-tests/src/dali/utc-Dali-Scene.cpp | 660 ++++++++++++++++++++++++- dali/internal/render/common/render-manager.cpp | 6 +- 2 files changed, 646 insertions(+), 20 deletions(-) diff --git a/automated-tests/src/dali/utc-Dali-Scene.cpp b/automated-tests/src/dali/utc-Dali-Scene.cpp index e4e0369..0dd5e19 100644 --- a/automated-tests/src/dali/utc-Dali-Scene.cpp +++ b/automated-tests/src/dali/utc-Dali-Scene.cpp @@ -1248,7 +1248,85 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 90, 90); + 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(); @@ -1268,6 +1346,7 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) // 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; @@ -1283,6 +1362,84 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) 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); @@ -1325,7 +1482,7 @@ int UtcDaliSceneSurfaceRotatedWithAngle180(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 180, 180); + 180, 0); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); @@ -1361,14 +1518,14 @@ int UtcDaliSceneSurfaceRotatedWithAngle180(void) // It should be changed. DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION); -DALI_TEST_EQUALS(screenOrientation, 180, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); END_TEST; } -int UtcDaliSceneSurfaceRotatedWithAngle270(void) +int UtcDaliSceneScreenRotatedWithAngle180(void) { - tet_infoline("Ensure rotation of the surface is handled properly with Angle 270"); + tet_infoline("Ensure rotation of the screen is handled properly with Angle 180"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1402,7 +1559,7 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 270, 270); + 0, 180); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); @@ -1422,10 +1579,10 @@ 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.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); @@ -1437,15 +1594,15 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. - DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); - DALI_TEST_EQUALS(screenOrientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 180, TEST_LOCATION); END_TEST; } -int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) +int UtcDaliSceneSurfaceAndScreenRotatedWithAngle180(void) { - tet_infoline("Ensure to acknowledge for completing surface 90 angle rotaiton"); + tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 180"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1463,6 +1620,8 @@ int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(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(); @@ -1472,14 +1631,15 @@ int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) 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, - 90, 90); + 180, 180); - // Check current surface orientation + // Check current orientations int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); @@ -1487,7 +1647,75 @@ int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) 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); + 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); @@ -1499,8 +1727,9 @@ 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; + // 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; @@ -1514,6 +1743,399 @@ int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. + DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneScreenRotatedWithAngle270(void) +{ + tet_infoline("Ensure rotation of the screen 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, + 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); + 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. (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 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 UtcDaliSceneSurfaceAndScreenRotatedWithAngle270(void) +{ + tet_infoline("Ensure rotation of the surface and the screen 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, 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); + 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.(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 orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 270, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSetSurfaceRotationCompletedAcknowledgementWithAngle90(void) +{ + tet_infoline("Ensure to acknowledge for completing surface 90 angle rotaiton"); + + 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); + 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.GetScene().SetRotationCompletedAcknowledgement(); + + 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_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); + + bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); + DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSetScreenRotationCompletedAcknowledgementWithAngle90(void) +{ + tet_infoline("Ensure to acknowledge for completing screen 90 angle rotaiton"); + + 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); + 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.GetScene().SetRotationCompletedAcknowledgement(); + + 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_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); + + bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); + DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSetSurfaceAndScreenRotationCompletedAcknowledgementWithAngle90(void) +{ + tet_infoline("Ensure to acknowledge for completing surface and screen 90 angle rotaiton"); + + 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); + 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.GetScene().SetRotationCompletedAcknowledgement(); + + 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, 90, TEST_LOCATION); DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); diff --git a/dali/internal/render/common/render-manager.cpp b/dali/internal/render/common/render-manager.cpp index fff4fe8..ba07eac 100644 --- a/dali/internal/render/common/render-manager.cpp +++ b/dali/internal/render/common/render-manager.cpp @@ -777,7 +777,11 @@ void RenderManager::RenderScene(Integration::RenderStatus& status, Integration:: Rect viewportRect; - int32_t surfaceOrientation = sceneObject->GetSurfaceOrientation(); + int32_t surfaceOrientation = sceneObject->GetSurfaceOrientation() + sceneObject->GetScreenOrientation(); + if(surfaceOrientation >= 360) + { + surfaceOrientation -= 360; + } // @todo Should these be part of scene? Integration::DepthBufferAvailable depthBufferAvailable = mImpl->depthBufferAvailable; -- 2.7.4