X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-Scene.cpp;h=fad981939d4c67b523707efae876874cbea9d817;hb=b067b6f30c7b8cfdaea9c39f7d2375ccb4e7fa81;hp=45eee5c0832349cf95672941cd0a95fd8c4a6514;hpb=cf0cc33fffbfc6dc9554b9dea13ebb7dd6f41b6e;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 45eee5c..fad9819 100644 --- a/automated-tests/src/dali/utc-Dali-Scene.cpp +++ b/automated-tests/src/dali/utc-Dali-Scene.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * Copyright (c) 2020 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,6 +25,7 @@ #include #include +#include // Internal headers are allowed here @@ -141,7 +142,7 @@ struct TouchFunctor if ( signalData.createNewScene ) { - Dali::Integration::Scene scene = Dali::Integration::Scene::New( Vector2( 480.0f, 800.0f ) ); + Dali::Integration::Scene scene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) ); DALI_TEST_CHECK( scene ); signalData.newSceneCreated = true; @@ -188,6 +189,50 @@ struct WheelEventReceivedFunctor WheelEventSignalData& signalData; }; +// Stores data that is populated in the KeyEventGeneratedSignal callback and will be read by the TET cases +struct KeyEventGeneratedSignalData +{ + KeyEventGeneratedSignalData() + : functorCalled(false) + {} + + void Reset() + { + functorCalled = false; + + receivedKeyEvent.keyModifier = 0; + receivedKeyEvent.keyPressedName.clear(); + receivedKeyEvent.keyPressed.clear(); + } + + bool functorCalled; + KeyEvent receivedKeyEvent; +}; + +// Functor that sets the data when called +struct KeyEventGeneratedReceivedFunctor +{ + KeyEventGeneratedReceivedFunctor( KeyEventGeneratedSignalData& data ) + : signalData( data ) + {} + + bool operator()( const KeyEvent& keyEvent ) + { + signalData.functorCalled = true; + signalData.receivedKeyEvent = keyEvent; + + return true; + } + + bool operator()() + { + signalData.functorCalled = true; + return true; + } + + KeyEventGeneratedSignalData& signalData; +}; + void GenerateTouch( TestApplication& application, PointState::Type state, const Vector2& screenPosition ) { Integration::TouchEvent touchEvent; @@ -361,7 +406,7 @@ int UtcDaliSceneDiscard(void) tet_infoline("Testing Dali::Scene::Discard"); // Create a new Scene - Dali::Integration::Scene scene = Dali::Integration::Scene::New( Vector2( 480.0f, 800.0f ) ); + Dali::Integration::Scene scene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) ); DALI_TEST_CHECK( scene ); // One reference of scene kept here and the other one kept in the Core @@ -431,12 +476,16 @@ int UtcDaliSceneRootLayerAndSceneAlignment(void) TestApplication application; // Create a Scene - Dali::Integration::Scene scene = Dali::Integration::Scene::New( Vector2( 480.0f, 800.0f ) ); + Dali::Integration::Scene scene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) ); DALI_TEST_CHECK( scene ); // One reference of scene kept here and the other one kept in the Core DALI_TEST_CHECK( scene.GetBaseObject().ReferenceCount() == 2 ); + // Add a renderable actor to the scene + auto actor = CreateRenderableActor(); + scene.Add( actor ); + // Render and notify. application.SendNotification(); application.Render(0); @@ -462,7 +511,7 @@ int UtcDaliSceneRootLayerAndSceneAlignment(void) DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 1 ); // Create a new Scene while the root layer of the deleted scene is still alive - Dali::Integration::Scene newScene = Dali::Integration::Scene::New( Vector2( 480.0f, 800.0f ) ); + Dali::Integration::Scene newScene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) ); DALI_TEST_CHECK( newScene ); // Render and notify. @@ -826,18 +875,249 @@ int UtcDaliSceneSignalWheelEventP(void) END_TEST; } -int UtcDaliSceneEnsureEmptySceneCleared(void) +int UtcDaliSceneSurfaceResizedDefaultScene(void) +{ + tet_infoline( "Ensure resizing of the surface is handled properly" ); + + TestApplication application; + + auto defaultScene = application.GetScene(); + DALI_TEST_CHECK( defaultScene ); + + // Ensure stage size matches the scene size + auto stage = Stage::GetCurrent(); + DALI_TEST_EQUALS( stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION ); + + // Resize the scene + Vector2 newSize( 1000.0f, 2000.0f ); + DALI_TEST_CHECK( stage.GetSize() != newSize ); + + defaultScene.SurfaceResized( newSize.width, newSize.height, 0, false ); + + DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION ); + DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void) { - tet_infoline( "Ensure we clear the newly added window" ); + tet_infoline( "Ensure resizing of the surface & viewport is handled properly" ); TestApplication application; + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + TraceCallStack& callStack = glAbstraction.GetViewportTrace(); + glAbstraction.EnableViewportCallTrace( true ); + + // Initial scene setup + Geometry geometry = CreateQuadGeometry(); + Shader shader = CreateShader(); + Renderer renderer = Renderer::New( geometry, shader ); + + Actor actor = Actor::New(); + actor.AddRenderer(renderer); + actor.SetSize(400, 400); + Stage::GetCurrent().Add(actor); + + // Render before resizing surface + application.SendNotification(); + application.Render(0); + glAbstraction.ResetViewportCallStack(); - // Create a new scene and set the background colors of both the new and the main scenes auto defaultScene = application.GetScene(); - defaultScene.SetBackgroundColor( Color::WHITE ); + DALI_TEST_CHECK( defaultScene ); + + // Ensure stage size matches the scene size + auto stage = Stage::GetCurrent(); + DALI_TEST_EQUALS( stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION ); + + // Resize the scene + Vector2 newSize( 1000.0f, 2000.0f ); + std::string viewportParams( "0, 0, 1000, 2000" ); // to match newSize + DALI_TEST_CHECK( stage.GetSize() != newSize ); + defaultScene.SurfaceResized( newSize.width, newSize.height, 0, false ); + + DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION ); + DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION ); + + // Render after resizing surface + application.SendNotification(); + application.Render(0); + + // Check that the viewport is handled properly + DALI_TEST_CHECK( callStack.FindMethodAndGetParameters("Viewport", viewportParams ) ); + + END_TEST; +} + +int UtcDaliSceneSurfaceResizedMultipleRenderTasks(void) +{ + tet_infoline( "Ensure resizing of the surface & viewport is handled properly" ); + + TestApplication application; + TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); + TraceCallStack& callStack = glAbstraction.GetViewportTrace(); + glAbstraction.EnableViewportCallTrace( true ); + + // Initial scene setup + auto stage = Stage::GetCurrent(); + + Geometry geometry = CreateQuadGeometry(); + Shader shader = CreateShader(); + Renderer renderer = Renderer::New( geometry, shader ); - auto newScene = Integration::Scene::New( Vector2( 480.0f, 800.0f ) ); - newScene.SetBackgroundColor( Color::RED ); + Actor actor = Actor::New(); + actor.AddRenderer(renderer); + int testWidth = 400; + int testHeight = 400; + actor.SetSize(testWidth, testHeight); + stage.Add(actor); + + CameraActor offscreenCameraActor = CameraActor::New( Size( testWidth, testHeight ) ); + Stage::GetCurrent().Add( offscreenCameraActor ); + + FrameBuffer newFrameBuffer = FrameBuffer::New( testWidth, testHeight, FrameBuffer::Attachment::NONE ); + + RenderTask newTask = stage.GetRenderTaskList().CreateTask(); + newTask.SetCameraActor( offscreenCameraActor ); + newTask.SetSourceActor( actor ); + newTask.SetFrameBuffer( newFrameBuffer ); + newTask.SetViewportPosition( Vector2(0, 0) ); + newTask.SetViewportSize( Vector2(testWidth, testHeight) ); + + // Render before resizing surface + application.SendNotification(); + application.Render(0); + glAbstraction.ResetViewportCallStack(); + + Rect initialViewport = newTask.GetViewport(); + int initialWidth = initialViewport.width; + int initialHeight = initialViewport.height; + DALI_TEST_EQUALS( initialWidth, testWidth, TEST_LOCATION ); + DALI_TEST_EQUALS( initialHeight, testHeight, TEST_LOCATION ); + + auto defaultScene = application.GetScene(); + DALI_TEST_CHECK( defaultScene ); + + // Ensure stage size matches the scene size + DALI_TEST_EQUALS( stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION ); + + // Resize the scene + Vector2 newSize( 1000.0f, 2000.0f ); + std::string viewportParams( "0, 0, 1000, 2000" ); // to match newSize + DALI_TEST_CHECK( stage.GetSize() != newSize ); + defaultScene.SurfaceResized( newSize.width, newSize.height, 0, false ); + + DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION ); + DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION ); + + // Render after resizing surface + application.SendNotification(); + application.Render(0); + + // Check that the viewport is handled properly + DALI_TEST_CHECK( callStack.FindMethodAndGetParameters("Viewport", viewportParams ) ); + + // Second render-task should not be affected + Rect viewport = newTask.GetViewport(); + int width = viewport.width; + int height = viewport.height; + DALI_TEST_EQUALS( width, testWidth, TEST_LOCATION ); + DALI_TEST_EQUALS( height, testHeight, TEST_LOCATION ); + + END_TEST; +} + +int UtcDaliSceneSurfaceResizedAdditionalScene(void) +{ + tet_infoline( "Ensure resizing of the surface is handled properly on additional scenes" ); + + TestApplication application; + Vector2 originalSurfaceSize( 500.0f, 1000.0f ); + + 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, 0, false ); + + // 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; +} + +int UtcDaliSceneKeyEventGeneratedSignalP(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + KeyEventGeneratedSignalData data; + KeyEventGeneratedReceivedFunctor functor( data ); + scene.KeyEventGeneratedSignal().Connect( &application, functor ); + + Integration::KeyEvent event( "a", "", "a", 0, 0, 0, Integration::KeyEvent::Up, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ); + application.ProcessEvent( event ); + + DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION ); + DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier ); + DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName ); + DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed ); + DALI_TEST_CHECK( event.state == static_cast( data.receivedKeyEvent.state ) ); + + data.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, data.functorCalled, TEST_LOCATION ); + DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier ); + DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName ); + DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed ); + DALI_TEST_CHECK( event2.state == static_cast( data.receivedKeyEvent.state ) ); + + data.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, data.functorCalled, TEST_LOCATION ); + DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier ); + DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName ); + DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed ); + DALI_TEST_CHECK( event3.state == static_cast( data.receivedKeyEvent.state ) ); + + data.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, data.functorCalled, TEST_LOCATION ); + DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier ); + DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName ); + DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed ); + DALI_TEST_CHECK( event4.state == static_cast( data.receivedKeyEvent.state ) ); + END_TEST; +} + +int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void) +{ + tet_infoline( "Ensure we keep background color when the scene surface is replaced " ); + + TestApplication application; + + // Create a new scene and set the background color of the main scene + auto defaultScene = application.GetScene(); + defaultScene.SetBackgroundColor( Color::BLUE ); // Need to create a renderable as we don't start rendering until we have at least one // We don't need to add this to any scene @@ -849,25 +1129,42 @@ int UtcDaliSceneEnsureEmptySceneCleared(void) application.SendNotification(); application.Render(); - DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION ); + DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION ); + DALI_TEST_EQUALS( glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION ); - // Add the actor to the main scene - defaultScene.Add( actor ); + defaultScene.SurfaceReplaced(); application.SendNotification(); application.Render(); - // Add another scene and set its background color, ensure we clear it to the appropriate color + DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION ); + DALI_TEST_EQUALS( glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION ); - auto thirdScene = Integration::Scene::New( Vector2( 200.0f, 200.0f ) ); - thirdScene.SetBackgroundColor( Color::BLUE ); + // Check when the main render task viewport is set the clear color is clipped using scissors + TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace(); + TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace(); + scissorTrace.Enable( true ); + enabledDisableTrace.Enable( true ); - clearCountBefore = glAbstraction.GetClearCountCalled(); + defaultScene.GetRenderTaskList().GetTask( 0 ).SetViewport( Viewport( 0.0f, 0.0f, 100.0f, 100.0f ) ); application.SendNotification(); application.Render(); + // Check scissor test was enabled. + DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST) + + // Check the scissor was set, and the coordinates are correct. + DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", "0, 700, 100, 100" ) ); + DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION ); + DALI_TEST_EQUALS( glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION ); + + scissorTrace.Enable( false ); + scissorTrace.Reset(); + + enabledDisableTrace.Enable( false ); + enabledDisableTrace.Reset(); END_TEST; }