/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/events/hit-test-algorithm.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/events/hit-test-algorithm.h>
#include <dali/integration-api/debug.h>
+#include <dali/public-api/dali-core.h>
+#include <mesh-builder.h>
+#include <stdlib.h>
+#include <test-actor-utils.h>
#include <test-native-image.h>
-#include <mesh-builder.h>
+#include <iostream>
-#define BOOLSTR(x) ((x)?"T":"F")
+#define BOOLSTR(x) ((x) ? "T" : "F")
//& set: DaliRenderTask
namespace // unnamed namespace
{
-
-const int RENDER_FRAME_INTERVAL = 16; ///< Duration of each frame in ms. (at approx 60FPS)
+const int RENDER_FRAME_INTERVAL = 16; ///< Duration of each frame in ms. (at approx 60FPS)
/*
* Simulate time passed by.
{
int time = 0;
- for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
+ for(int i = 0; i <= (duration / RENDER_FRAME_INTERVAL); i++)
{
application.SendNotification();
application.Render(RENDER_FRAME_INTERVAL);
struct RenderTaskFinished
{
- RenderTaskFinished( bool& finished )
- : finished( finished )
+ RenderTaskFinished(bool& finished)
+ : finished(finished)
{
}
- void operator()( RenderTask& renderTask )
+ void operator()(RenderTask& renderTask)
{
finished = true;
}
struct RenderTaskFinishedRemoveSource
{
- RenderTaskFinishedRemoveSource( bool& finished )
- : finished( finished ),
+ RenderTaskFinishedRemoveSource(bool& finished)
+ : finished(finished),
finishedOnce(false)
{
}
- void operator()( RenderTask& renderTask )
+ void operator()(RenderTask& renderTask)
{
DALI_TEST_CHECK(finishedOnce == false);
- finished = true;
- finishedOnce = true;
+ finished = true;
+ finishedOnce = true;
Actor srcActor = renderTask.GetSourceActor();
UnparentAndReset(srcActor);
}
bool& finished;
- bool finishedOnce;
+ bool finishedOnce;
};
struct RenderTaskFinishedRenderAgain
{
- RenderTaskFinishedRenderAgain( bool& finished )
- : finished( finished ),
+ RenderTaskFinishedRenderAgain(bool& finished)
+ : finished(finished),
finishedOnce(false)
{
}
- void operator()( RenderTask& renderTask )
+ void operator()(RenderTask& renderTask)
{
DALI_TEST_CHECK(finishedOnce == false);
- finished = true;
+ finished = true;
finishedOnce = true;
renderTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
}
bool& finished;
- bool finishedOnce;
+ bool finishedOnce;
};
-
-bool TestScreenToFrameBufferFunction( Vector2& coordinates )
+bool TestScreenToFrameBufferFunction(Vector2& coordinates)
{
- coordinates = coordinates + Vector2( 1, 2 );
+ coordinates = coordinates + Vector2(1, 2);
return true;
}
-ImageActor CreateLoadingImageActor(TestApplication& application, std::string filename, ResourceImage::LoadPolicy loadPolicy, Image::ReleasePolicy releasePolicy)
+Actor CreateRenderableActorSuccess(TestApplication& application, std::string filename)
{
- Image image = ResourceImage::New(filename, loadPolicy, releasePolicy);
- DALI_TEST_CHECK( image );
- application.SendNotification();
- application.Render(16);
- DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
- ImageActor actor = ImageActor::New(image);
- actor.SetSize( 80, 80 );
- application.SendNotification();
- application.Render(16);
+ Actor actor = CreateRenderableActor();
+ actor.SetProperty(Actor::Property::SIZE, Vector2(80.0f, 80.0f));
return actor;
}
-Image CreateLoadingImage(TestApplication& application, std::string filename, ResourceImage::LoadPolicy loadPolicy, Image::ReleasePolicy releasePolicy)
-{
- Image image = ResourceImage::New(filename, loadPolicy, releasePolicy);
- DALI_TEST_CHECK( image );
- application.SendNotification();
- application.Render(16);
- DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
-
- return image;
-}
-
-void CompleteImageLoad(TestApplication& application, Integration::ResourceId resourceId, Integration::ResourceTypeId requestType)
-{
- std::vector<GLuint> ids;
- ids.push_back( 23 );
- application.GetGlAbstraction().SetNextTextureIds( ids );
-
- Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
- Integration::ResourcePointer resource(bitmap);
- bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
-
- application.GetPlatform().SetResourceLoaded(resourceId, requestType, resource);
-}
-
-void FailImageLoad(TestApplication& application, Integration::ResourceId resourceId )
+Texture CreateTexture(void)
{
- application.GetPlatform().SetResourceLoadFailed(resourceId, Integration::FailureUnknown);
-}
-
-void ReloadImage(TestApplication& application, ResourceImage image)
-{
- application.GetPlatform().ClearReadyResources();
- application.GetPlatform().DiscardRequest();
- application.GetPlatform().ResetTrace();
- application.GetPlatform().SetClosestImageSize(Vector2(80.0f, 80.0f)); // Ensure reload is called.
- image.Reload();
+ return Dali::CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 80, 80);
}
RenderTask CreateRenderTask(TestApplication& application,
- CameraActor offscreenCamera,
- Actor rootActor, // Reset default render task to point at this actor
- Actor secondRootActor, // Source actor
- unsigned int refreshRate,
- bool glSync)
+ CameraActor offscreenCamera,
+ Actor rootActor, // Reset default render task to point at this actor
+ Actor secondRootActor, // Source actor
+ unsigned int refreshRate,
+ bool glSync,
+ uint32_t frameBufferWidth = 10,
+ uint32_t frameBufferHeight = 10)
{
// Change main render task to use a different root
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- taskList.GetTask(0u).SetSourceActor( rootActor );
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ taskList.GetTask(0u).SetSourceActor(rootActor);
- FrameBufferImage frameBufferImage;
- if( glSync )
+ FrameBuffer frameBuffer = FrameBuffer::New(frameBufferWidth, frameBufferHeight);
+ if(glSync)
{
- NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
- frameBufferImage= FrameBufferImage::New( *(testNativeImagePtr.Get()) );
- }
- else
- {
- frameBufferImage = FrameBufferImage::New( 10, 10 );
+ NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(frameBufferWidth, frameBufferHeight);
+ Texture texture = Texture::New(*testNativeImagePtr);
+ frameBuffer.AttachColorTexture(texture);
}
// Don't draw output framebuffer // '
RenderTask newTask = taskList.CreateTask();
- newTask.SetCameraActor( offscreenCamera );
- newTask.SetSourceActor( secondRootActor );
- newTask.SetInputEnabled( false );
- newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
- newTask.SetClearEnabled( true );
- newTask.SetExclusive( true );
- newTask.SetRefreshRate( refreshRate );
- newTask.SetTargetFrameBuffer( frameBufferImage );
+ newTask.SetCameraActor(offscreenCamera);
+ newTask.SetSourceActor(secondRootActor);
+ newTask.SetInputEnabled(false);
+ newTask.SetClearColor(Vector4(0.f, 0.f, 0.f, 0.f));
+ newTask.SetClearEnabled(true);
+ newTask.SetExclusive(true);
+ newTask.SetRefreshRate(refreshRate);
+ newTask.SetFrameBuffer(frameBuffer);
+ newTask.SetProperty(RenderTask::Property::REQUIRES_SYNC, glSync);
return newTask;
}
-bool UpdateRender(TestApplication& application, TraceCallStack& callStack, bool testDrawn, bool& finishedSig, bool testFinished, bool testKeepUpdating, int lineNumber )
+bool UpdateRender(TestApplication& application, TraceCallStack& callStack, bool testDrawn, bool& finishedSig, bool testFinished, bool testKeepUpdating, int lineNumber)
{
finishedSig = false;
callStack.Reset();
application.SendNotification();
bool sigPassed = false;
- if( testFinished )
+ if(testFinished)
{
sigPassed = finishedSig;
}
else
{
- sigPassed = ! finishedSig;
+ sigPassed = !finishedSig;
}
bool drawResult = callStack.FindMethod("DrawElements") || callStack.FindMethod("DrawArrays");
bool drawPassed = false;
- if( testDrawn )
+ if(testDrawn)
{
drawPassed = drawResult;
}
drawPassed = !drawResult;
}
- bool keepUpdating = (application.GetUpdateStatus() != 0);
+ bool keepUpdating = (application.GetUpdateStatus() != 0);
bool keepUpdatingPassed = false;
- if( testKeepUpdating )
+ if(testKeepUpdating)
{
keepUpdatingPassed = keepUpdating;
}
bool result = (sigPassed && drawPassed && keepUpdatingPassed);
tet_printf("UpdateRender: Expected: Draw:%s Signal:%s KeepUpdating: %s Actual: Draw:%s Signal:%s KeepUpdating: %s %s, line %d\n",
- BOOLSTR(testDrawn), BOOLSTR(testFinished), BOOLSTR(testKeepUpdating),
- BOOLSTR(drawResult), BOOLSTR(finishedSig), BOOLSTR(keepUpdating),
- result ? "Passed":"Failed",
- lineNumber );
+ BOOLSTR(testDrawn),
+ BOOLSTR(testFinished),
+ BOOLSTR(testKeepUpdating),
+ BOOLSTR(drawResult),
+ BOOLSTR(finishedSig),
+ BOOLSTR(keepUpdating),
+ result ? "Passed" : "Failed",
+ lineNumber);
return result;
}
-// The functor to be used in the hit-test algorithm to check whether the actor is hittable.
-bool IsActorHittableFunction(Actor actor, Dali::HitTestAlgorithm::TraverseType type)
-{
- bool hittable = false;
-
- switch (type)
- {
- case Dali::HitTestAlgorithm::CHECK_ACTOR:
- {
- // Check whether the actor is visible and not fully transparent.
- if( actor.IsVisible()
- && actor.GetCurrentWorldColor().a > 0.01f) // not FULLY_TRANSPARENT
- {
-
- hittable = true;
- }
- break;
- }
- case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
- {
- if( actor.IsVisible() ) // Actor is visible, if not visible then none of its children are visible.
- {
- hittable = true;
- }
- break;
- }
- default:
- {
- break;
- }
- }
-
- return hittable;
-}
-
} // unnamed namespace
-
/****************************************************************************************************/
/****************************************************************************************************/
/******************************** TEST CASES BELOW **********************************************/
tet_infoline("Testing RenderTask::DownCast()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- BaseHandle base = taskList.GetTask( 0u );
- DALI_TEST_CHECK( base );
+ BaseHandle base = taskList.GetTask(0u);
+ DALI_TEST_CHECK(base);
- RenderTask task = RenderTask::DownCast( base );
- DALI_TEST_CHECK( task );
+ RenderTask task = RenderTask::DownCast(base);
+ DALI_TEST_CHECK(task);
// Try calling a method
- DALI_TEST_CHECK( task.GetSourceActor() );
+ DALI_TEST_CHECK(task.GetSourceActor());
END_TEST;
}
Actor actor = Actor::New();
- RenderTask task = RenderTask::DownCast( actor );
- DALI_TEST_CHECK( ! task );
+ RenderTask task = RenderTask::DownCast(actor);
+ DALI_TEST_CHECK(!task);
END_TEST;
}
{
TestApplication application;
tet_infoline("Testing RenderTask::SetSourceActor() Negative - try with empty actor handle");
- Stage stage = Stage::GetCurrent();
+ Integration::Scene stage = application.GetScene();
Actor srcActor;
- RenderTaskList taskList = stage.GetRenderTaskList();
- RenderTask renderTask = taskList.CreateTask();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask renderTask = taskList.CreateTask();
renderTask.SetSourceActor(srcActor);
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( ! renderTask.GetSourceActor() );
+ DALI_TEST_CHECK(!renderTask.GetSourceActor());
END_TEST;
}
-
int UtcDaliRenderTaskSetSourceActorP01(void)
{
TestApplication application;
tet_infoline("Testing RenderTask::SetSourceActor() Positive - check that setting a non-renderable actor stops existing source actor being rendered ");
- Stage stage = Stage::GetCurrent();
-
- const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
-
- RenderTaskList taskList = stage.GetRenderTaskList();
-
- RenderTask task = taskList.GetTask( 0u );
+ Integration::Scene stage = application.GetScene();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
- std::vector<GLuint> ids;
- ids.push_back( 7 );
- application.GetGlAbstraction().SetNextTextureIds( ids );
-
- BufferImage img = BufferImage::New( 1,1 );
- ImageActor newActor = ImageActor::New( img );
- newActor.SetSize(1,1);
- stage.Add( newActor );
+ Texture img = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor newActor = CreateRenderableActor(img);
+ newActor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ stage.Add(newActor);
Actor nonRenderableActor = Actor::New();
- stage.Add( nonRenderableActor );
+ stage.Add(nonRenderableActor);
// Stop the newActor from being rendered by changing the source actor
- DALI_TEST_CHECK( nonRenderableActor );
- task.SetSourceActor( nonRenderableActor );
- DALI_TEST_CHECK( task.GetSourceActor() != actor );
- DALI_TEST_CHECK( task.GetSourceActor() == nonRenderableActor );
+ DALI_TEST_CHECK(nonRenderableActor);
+ task.SetSourceActor(nonRenderableActor);
+ DALI_TEST_CHECK(task.GetSourceActor() != actor);
+ DALI_TEST_CHECK(task.GetSourceActor() == nonRenderableActor);
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
+ drawTrace.Enable(true);
// Update & Render nothing!
application.GetGlAbstraction().ClearBoundTextures();
application.Render();
// Check that nothing was rendered
- DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRenderTaskSetSourceActorP02(void)
{
TestApplication application;
tet_infoline("Testing RenderTask::SetSourceActor() Positive - check that switching source from a non-renderable to a renderable actor causes the texture to be drawn");
- Stage stage = Stage::GetCurrent();
-
- const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
+ Integration::Scene stage = application.GetScene();
RenderTaskList taskList = stage.GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
-
- std::vector<GLuint> ids;
- ids.push_back( 7 );
- application.GetGlAbstraction().SetNextTextureIds( ids );
+ DALI_TEST_CHECK(actor);
- BufferImage img = BufferImage::New( 1,1 );
- ImageActor newActor = ImageActor::New( img );
- newActor.SetSize(1,1);
- stage.Add( newActor );
+ Texture img = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor newActor = CreateRenderableActor(img);
+ newActor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ stage.Add(newActor);
Actor nonRenderableActor = Actor::New();
- stage.Add( nonRenderableActor );
+ stage.Add(nonRenderableActor);
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
+ drawTrace.Enable(true);
// Stop the newActor from being rendered by changing the source actor
- DALI_TEST_CHECK( nonRenderableActor );
- task.SetSourceActor( nonRenderableActor );
- DALI_TEST_CHECK( task.GetSourceActor() != actor );
- DALI_TEST_CHECK( task.GetSourceActor() == nonRenderableActor );
+ DALI_TEST_CHECK(nonRenderableActor);
+ task.SetSourceActor(nonRenderableActor);
+ DALI_TEST_CHECK(task.GetSourceActor() != actor);
+ DALI_TEST_CHECK(task.GetSourceActor() == nonRenderableActor);
// Update & Render nothing!
application.GetGlAbstraction().ClearBoundTextures();
application.Render();
// Check that nothing was rendered
- DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
+ drawTrace.Reset();
// Set newActor as the new source Actor
- task.SetSourceActor( newActor );
- DALI_TEST_CHECK( task.GetSourceActor() != actor );
- DALI_TEST_CHECK( task.GetSourceActor() == newActor );
+ task.SetSourceActor(newActor);
+ DALI_TEST_CHECK(task.GetSourceActor() != actor);
+ DALI_TEST_CHECK(task.GetSourceActor() == newActor);
// Update & Render the newActor
application.GetGlAbstraction().ClearBoundTextures();
application.Render();
// Check that the newActor was rendered
- DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
- if ( boundTextures.size() )
- {
- DALI_TEST_EQUALS( boundTextures[0], 7u, TEST_LOCATION );
- }
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
END_TEST;
}
-int UtcDaliRenderTaskSetSourceActorOffStage(void)
+int UtcDaliRenderTaskSetSourceActorOffScene(void)
{
TestApplication application;
tet_infoline("Testing RenderTask::SetSourceActor (on/off stage testing)");
- Stage stage = Stage::GetCurrent();
-
- const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
-
- RenderTaskList taskList = stage.GetRenderTaskList();
-
- RenderTask task = taskList.GetTask( 0u );
+ Integration::Scene stage = application.GetScene();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
- std::vector<GLuint> ids;
- GLuint expectedTextureId( 3 );
- ids.push_back( expectedTextureId );
- application.GetGlAbstraction().SetNextTextureIds( ids );
-
- BufferImage img = BufferImage::New( 1,1 );
- ImageActor newActor = ImageActor::New( img );
- newActor.SetSize(1,1);
- task.SetSourceActor( newActor );
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
+ drawTrace.Enable(true);
+
+ Texture img = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor newActor = CreateRenderableActor(img);
+ newActor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ task.SetSourceActor(newActor);
// Don't add newActor to stage yet //'
// Update & Render with the actor initially off-stage
- application.GetGlAbstraction().ClearBoundTextures();
application.SendNotification();
application.Render();
// Check that nothing was rendered
- DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
// Now add to stage
- stage.Add( newActor );
+ stage.Add(newActor);
// Update & Render with the actor on-stage
application.GetGlAbstraction().ClearBoundTextures();
application.Render();
// Check that the newActor was rendered
- DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
- if ( boundTextures.size() )
- {
- DALI_TEST_EQUALS( boundTextures[0], expectedTextureId, TEST_LOCATION );
- }
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
+ drawTrace.Reset();
// Now remove from stage
- stage.Remove( newActor );
+ stage.Remove(newActor);
// Update & Render with the actor off-stage
- application.GetGlAbstraction().ClearBoundTextures();
application.SendNotification();
application.Render();
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
+
END_TEST;
}
tet_infoline("Testing RenderTask::SetSourceActor (empty handle case)");
- Stage stage = Stage::GetCurrent();
-
- const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
-
- RenderTaskList taskList = stage.GetRenderTaskList();
-
- RenderTask task = taskList.GetTask( 0u );
+ Integration::Scene stage = application.GetScene();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
-
- std::vector<GLuint> ids;
- GLuint expectedTextureId( 5 );
- ids.push_back( expectedTextureId );
- application.GetGlAbstraction().SetNextTextureIds( ids );
+ DALI_TEST_CHECK(actor);
- BufferImage img = BufferImage::New( 1,1 );
- ImageActor newActor = ImageActor::New( img );
- newActor.SetSize(1,1);
- stage.Add( newActor );
+ Texture img = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor newActor = CreateRenderableActor(img);
+ newActor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ stage.Add(newActor);
Actor nonRenderableActor = Actor::New();
- stage.Add( nonRenderableActor );
+ stage.Add(nonRenderableActor);
// Set with empty handle
- task.SetSourceActor( Actor() );
- DALI_TEST_CHECK( ! task.GetSourceActor() );
+ task.SetSourceActor(Actor());
+ DALI_TEST_CHECK(!task.GetSourceActor());
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
+ drawTrace.Enable(true);
// Update & Render nothing!
- application.GetGlAbstraction().ClearBoundTextures();
application.SendNotification();
application.Render();
// Check that nothing was rendered
- DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
// Set with non-empty handle
- task.SetSourceActor( newActor );
- DALI_TEST_CHECK( task.GetSourceActor() == newActor );
+ task.SetSourceActor(newActor);
+ DALI_TEST_CHECK(task.GetSourceActor() == newActor);
// Update & Render the newActor
application.GetGlAbstraction().ClearBoundTextures();
application.Render();
// Check that the newActor was rendered
- DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
- if ( boundTextures.size() )
- {
- DALI_TEST_EQUALS( boundTextures[0], expectedTextureId, TEST_LOCATION );
- }
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetSourceActorDestroyed(void)
+{
+ TestApplication application;
+
+ tet_infoline("Testing RenderTask::SetSourceActor - Set a source actor and destroy the source actor");
+
+ Integration::Scene stage = application.GetScene();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
+
+ Actor actor = task.GetSourceActor();
+ DALI_TEST_CHECK(actor);
+
+ Texture img = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+
+ Actor newActor = CreateRenderableActor(img);
+ newActor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ stage.Add(newActor);
+
+ task.SetSourceActor(newActor);
+
+ DALI_TEST_CHECK(task.GetSourceActor() != actor);
+ DALI_TEST_CHECK(task.GetSourceActor() == newActor);
+
+ application.SendNotification();
+ application.Render();
+
+ // Destroy the source actor
+ stage.Remove(newActor);
+ newActor.Reset();
+
+ DALI_TEST_CHECK(!task.GetSourceActor()); // The source actor should be an empty handle.
+
END_TEST;
}
tet_infoline("Testing RenderTask::GetSourceActor() Check the default render task has a valid source actor");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
// By default the entire scene should be rendered
- Actor root = Stage::GetCurrent().GetLayer( 0 );
- DALI_TEST_CHECK( root == actor );
+ Actor root = application.GetScene().GetLayer(0);
+ DALI_TEST_CHECK(root == actor);
END_TEST;
}
tet_infoline("Testing RenderTask::GetSourceActor() Create a new render task, Add a new actor to the stage and set it as the source of the new render task. Get its source actor and check that it is equivalent to what was set.");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask task = taskList.CreateTask();
- Actor actor = Actor::New();
- Stage::GetCurrent().Add(actor);
- task.SetSourceActor( actor );
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.CreateTask();
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+ task.SetSourceActor(actor);
- DALI_TEST_EQUALS( actor, task.GetSourceActor(), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor, task.GetSourceActor(), TEST_LOCATION);
END_TEST;
}
{
Actor actor = task.GetSourceActor();
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
tet_infoline("Testing RenderTask::SetExclusive() Check that exclusion works");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+
+ // Creates:
+ // Root
+ // Actor1 Layer Layer
+ // Actor2 Actor3
- // Manipulate the GenTextures behaviour, to identify different ImageActors
+ // Task 1 is the default render task, should render from Root, incl Actor2
+ // Task 2 uses Actor2 as a source actor (texture id 9)
+
+ // Manipulate the GenTextures behaviour, to identify different actors
std::vector<GLuint> ids;
- ids.push_back( 8 ); // 8 = actor1
- ids.push_back( 9 ); // 9 = actor2
- ids.push_back( 10 ); // 10 = actor3
- application.GetGlAbstraction().SetNextTextureIds( ids );
+ ids.push_back(8); // 8 = actor1
+ ids.push_back(9); // 9 = actor2
+ ids.push_back(10); // 10 = actor3
+ application.GetGlAbstraction().SetNextTextureIds(ids);
- BufferImage img1 = BufferImage::New( 1,1 );
- ImageActor actor1 = ImageActor::New( img1 );
- actor1.SetSize(1,1);
- Stage::GetCurrent().Add( actor1 );
+ Texture img1 = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor actor1 = CreateRenderableActor(img1);
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ application.GetScene().Add(actor1);
// Update & Render actor1
application.SendNotification();
application.Render();
// Check that the actor1 was rendered
- const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
- DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
+ const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures(GL_TEXTURE0);
+ DALI_TEST_GREATER(boundTextures.size(), static_cast<std::vector<GLuint>::size_type>(0), TEST_LOCATION);
- if ( boundTextures.size() )
+ if(boundTextures.size())
{
- DALI_TEST_EQUALS( boundTextures[0], 8u/*unique to actor1*/, TEST_LOCATION );
+ int a = boundTextures.size() - 1;
+ DALI_TEST_EQUALS(boundTextures[a], 8u /*unique to actor1*/, TEST_LOCATION);
}
- BufferImage img2 = BufferImage::New( 1,1 );
- ImageActor actor2 = ImageActor::New( img2 );
- actor2.SetSize(1,1);
+ Texture img2 = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+
+ Actor actor2 = CreateRenderableActor(img2);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
// Force actor2 to be rendered before actor1
Layer layer = Layer::New();
- Stage::GetCurrent().Add( layer );
- layer.Add( actor2 );
+ application.GetScene().Add(layer);
+ layer.Add(actor2);
layer.LowerToBottom();
// Update & Render
application.Render();
// Check that the actors were rendered
- DALI_TEST_EQUALS( boundTextures.size(), 2u, TEST_LOCATION );
+ DALI_TEST_GREATER(boundTextures.size(), static_cast<std::vector<GLuint>::size_type>(1), TEST_LOCATION);
- if ( boundTextures.size() )
+ if(boundTextures.size() >= 2)
{
- DALI_TEST_EQUALS( boundTextures[0], 9u/*unique to actor2*/, TEST_LOCATION );
- DALI_TEST_EQUALS( boundTextures[1], 8u/*unique to actor1*/, TEST_LOCATION );
+ int a = boundTextures.size() - 2;
+ int b = boundTextures.size() - 1;
+ DALI_TEST_EQUALS(boundTextures[a], 9u /*unique to actor2*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(boundTextures[b], 8u /*unique to actor1*/, TEST_LOCATION);
}
- BufferImage img3 = BufferImage::New( 1,1 );
- ImageActor actor3 = ImageActor::New( img3 );
- actor3.SetSize(1,1);
+ Texture img3 = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor actor3 = CreateRenderableActor(img3);
+ actor3.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
// Force actor3 to be rendered before actor2
layer = Layer::New();
- Stage::GetCurrent().Add( layer );
- layer.Add( actor3 );
+ application.GetScene().Add(layer);
+ layer.Add(actor3);
layer.LowerToBottom();
// Update & Render all actors
application.Render();
// Check that the actors were rendered
- DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
+ DALI_TEST_GREATER(boundTextures.size(), static_cast<std::vector<GLuint>::size_type>(2), TEST_LOCATION);
- if ( boundTextures.size() )
+ if(boundTextures.size() >= 3)
{
- DALI_TEST_EQUALS( boundTextures[0], 10u/*unique to actor3*/, TEST_LOCATION );
- DALI_TEST_EQUALS( boundTextures[1], 9u/*unique to actor2*/, TEST_LOCATION );
- DALI_TEST_EQUALS( boundTextures[2], 8u/*unique to actor1*/, TEST_LOCATION );
+ int a = boundTextures.size() - 3;
+ int b = boundTextures.size() - 2;
+ int c = boundTextures.size() - 1;
+ DALI_TEST_EQUALS(boundTextures[a], 10u /*unique to actor3*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(boundTextures[b], 9u /*unique to actor2*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(boundTextures[c], 8u /*unique to actor1*/, TEST_LOCATION);
}
// Both actors are now connected to the root node
// Setup 2 render-tasks - the first will render from the root-node, and the second from actor2
// Not exclusive is the default
- RenderTask task1 = taskList.GetTask( 0u );
- DALI_TEST_CHECK( false == task1.IsExclusive() );
+ RenderTask task1 = taskList.GetTask(0u);
+ DALI_TEST_CHECK(false == task1.IsExclusive());
RenderTask task2 = taskList.CreateTask();
- DALI_TEST_CHECK( false == task2.IsExclusive() );
- task2.SetSourceActor( actor2 );
+ DALI_TEST_CHECK(false == task2.IsExclusive());
+ task2.SetSourceActor(actor2);
// Task1 should render all actors, and task 2 should render only actor2
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( boundTextures.size(), 4u, TEST_LOCATION );
-
- if ( boundTextures.size() == 4 )
+ if(boundTextures.size() >= 4)
{
// Test that task 1 renders actor3, then actor2 & then actor1
- DALI_TEST_CHECK( boundTextures[0] == 10u );
- DALI_TEST_CHECK( boundTextures[1] == 9u );
- DALI_TEST_CHECK( boundTextures[2] == 8u );
+ int a = boundTextures.size() - 4;
+ int b = boundTextures.size() - 3;
+ int c = boundTextures.size() - 2;
+ int d = boundTextures.size() - 1;
+ DALI_TEST_EQUALS(boundTextures[a], 10u /*unique to actor3*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(boundTextures[b], 9u /*unique to actor2*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(boundTextures[c], 8u /*unique to actor1*/, TEST_LOCATION);
// Test that task 2 renders actor2
- DALI_TEST_EQUALS( boundTextures[3], 9u, TEST_LOCATION );
+ DALI_TEST_EQUALS(boundTextures[d], 9u, TEST_LOCATION);
}
// Make actor2 exclusive to task2
- task2.SetExclusive( true );
- DALI_TEST_CHECK( true == task2.IsExclusive() );
+ task2.SetExclusive(true);
+ DALI_TEST_CHECK(true == task2.IsExclusive());
// Task1 should render only actor1, and task 2 should render only actor2
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
- if ( boundTextures.size() == 3 )
+ DALI_TEST_EQUALS(boundTextures.size(), 3u, TEST_LOCATION);
+ if(boundTextures.size() == 3)
{
// Test that task 1 renders actor3 & actor1
- DALI_TEST_CHECK( boundTextures[0] == 10u );
- DALI_TEST_CHECK( boundTextures[1] == 8u );
+ DALI_TEST_CHECK(boundTextures[0] == 10u);
+ DALI_TEST_CHECK(boundTextures[1] == 8u);
// Test that task 2 renders actor2
- DALI_TEST_CHECK( boundTextures[2] == 9u );
+ DALI_TEST_CHECK(boundTextures[2] == 9u);
}
+
+ // Create a renderable actor and replace the source actor in task2
+ auto actor4 = CreateRenderableActor();
+ task2.SetSourceActor(actor3);
+ DALI_TEST_EQUALS(actor3, task2.GetSourceActor(), TEST_LOCATION);
+
END_TEST;
}
tet_infoline("Testing RenderTask::SetExclusive() Check that changing from exclusive to not-exclusive works");
std::vector<GLuint> ids;
- ids.push_back( 8 ); // 8 = actor1
- application.GetGlAbstraction().SetNextTextureIds( ids );
+ ids.push_back(8); // 8 = actor1
+ application.GetGlAbstraction().SetNextTextureIds(ids);
- BufferImage img1 = BufferImage::New( 1,1 );
- ImageActor actor1 = ImageActor::New( img1 );
- actor1.SetSize(1,1);
- Stage::GetCurrent().Add( actor1 );
+ Texture img1 = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor actor1 = CreateRenderableActor(img1);
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ application.GetScene().Add(actor1);
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask task = taskList.CreateTask();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.CreateTask();
- task.SetSourceActor( actor1 );
+ task.SetSourceActor(actor1);
task.SetExclusive(true); // Actor should only render once
- TestGlAbstraction& gl = application.GetGlAbstraction();
- TraceCallStack& drawTrace = gl.GetDrawTrace();
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
drawTrace.Enable(true);
// Update & Render actor1
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
// Set task to non-exclusive - actor1 should render twice:
drawTrace.Reset();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 2, TEST_LOCATION);
END_TEST;
}
{
task.SetExclusive(true);
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::IsExclusive() Check default values are non-exclusive");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// Not exclusive is the default
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( false == task.IsExclusive() );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(false == task.IsExclusive());
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_CHECK( false == newTask.IsExclusive() );
+ DALI_TEST_CHECK(false == newTask.IsExclusive());
END_TEST;
}
tet_infoline("Testing RenderTask::IsExclusive() Check the getter returns set values");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// Not exclusive is the default
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_EQUALS( newTask.IsExclusive(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(newTask.IsExclusive(), false, TEST_LOCATION);
newTask.SetExclusive(true);
- DALI_TEST_EQUALS( newTask.IsExclusive(), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(newTask.IsExclusive(), true, TEST_LOCATION);
END_TEST;
}
try
{
bool x = task.IsExclusive();
- x=x;
+ (void)x;
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::SetInputEnabled()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// Input is enabled by default
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( true == task.GetInputEnabled() );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(true == task.GetInputEnabled());
- task.SetInputEnabled( false );
- DALI_TEST_CHECK( false == task.GetInputEnabled() );
+ task.SetInputEnabled(false);
+ DALI_TEST_CHECK(false == task.GetInputEnabled());
- task.SetInputEnabled( true );
- DALI_TEST_CHECK( true == task.GetInputEnabled() );
+ task.SetInputEnabled(true);
+ DALI_TEST_CHECK(true == task.GetInputEnabled());
END_TEST;
}
tet_infoline("Testing RenderTask::GetInputEnabled()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// Input is enabled by default
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_EQUALS( true, task.GetInputEnabled(), TEST_LOCATION );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_EQUALS(true, task.GetInputEnabled(), TEST_LOCATION);
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_EQUALS( true, newTask.GetInputEnabled(), TEST_LOCATION );
+ DALI_TEST_EQUALS(true, newTask.GetInputEnabled(), TEST_LOCATION);
newTask.SetInputEnabled(false);
- DALI_TEST_EQUALS( false, newTask.GetInputEnabled(), TEST_LOCATION );
+ DALI_TEST_EQUALS(false, newTask.GetInputEnabled(), TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing RenderTask::SetCameraActor()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Actor defaultCameraActor = task.GetCameraActor();
- DALI_TEST_CHECK( defaultCameraActor );
+ DALI_TEST_CHECK(defaultCameraActor);
CameraActor newCameraActor = CameraActor::New();
- DALI_TEST_CHECK( newCameraActor );
+ DALI_TEST_CHECK(newCameraActor);
- task.SetCameraActor( newCameraActor );
- DALI_TEST_CHECK( task.GetCameraActor() != defaultCameraActor );
- DALI_TEST_EQUALS( task.GetCameraActor(), newCameraActor, TEST_LOCATION );
+ task.SetCameraActor(newCameraActor);
+ DALI_TEST_CHECK(task.GetCameraActor() != defaultCameraActor);
+ DALI_TEST_EQUALS(task.GetCameraActor(), newCameraActor, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRenderTaskSetCameraActorN(void)
{
TestApplication application;
tet_infoline("Testing RenderTask::SetCameraActor() with empty actor handle");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetCameraActor();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
CameraActor cameraActor;
- task.SetCameraActor( cameraActor );
- DALI_TEST_EQUALS( (bool)task.GetCameraActor(), false, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCameraActor(), cameraActor, TEST_LOCATION );
+ task.SetCameraActor(cameraActor);
+ DALI_TEST_EQUALS((bool)task.GetCameraActor(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCameraActor(), cameraActor, TEST_LOCATION);
END_TEST;
}
+int UtcDaliRenderTaskSetCameraActorDestroyed(void)
+{
+ TestApplication application;
+
+ tet_infoline("Testing RenderTask::SetCameraActor - Set a camera actor and destroy the camera actor");
+
+ Integration::Scene stage = application.GetScene();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
+
+ CameraActor newCameraActor = CameraActor::New();
+ task.SetCameraActor(newCameraActor);
+
+ DALI_TEST_EQUALS(task.GetCameraActor(), newCameraActor, TEST_LOCATION);
+
+ // Destroy the camera actor
+ newCameraActor.Reset();
+
+ CameraActor camera = task.GetCameraActor();
+ DALI_TEST_CHECK(!camera); // The camera actor should be an empty handle.
+
+ END_TEST;
+}
int UtcDaliRenderTaskGetCameraActorP(void)
{
tet_infoline("Testing RenderTask::GetCameraActor()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
CameraActor actor = task.GetCameraActor();
- DALI_TEST_CHECK( actor );
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
- DALI_TEST_GREATER( actor.GetFieldOfView(), 0.0f, TEST_LOCATION );
+ DALI_TEST_CHECK(actor);
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
+ DALI_TEST_GREATER(actor.GetFieldOfView(), 0.0f, TEST_LOCATION);
END_TEST;
}
{
Actor actor = task.GetCameraActor();
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
}
-int UtcDaliRenderTaskSetTargetFrameBufferP(void)
+int UtcDaliRenderTaskSetFrameBufferP(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask::SetTargetFrameBuffer()");
+ tet_infoline("Testing RenderTask::SetFrameBuffer()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
- FrameBufferImage newImage = FrameBufferImage::New();
- task.SetTargetFrameBuffer( newImage );
- DALI_TEST_CHECK( task.GetTargetFrameBuffer() == newImage );
+ FrameBuffer newFrameBuffer = FrameBuffer::New(128u, 128u, FrameBuffer::Attachment::NONE);
+ task.SetFrameBuffer(newFrameBuffer);
+ DALI_TEST_CHECK(task.GetFrameBuffer() == newFrameBuffer);
END_TEST;
}
-int UtcDaliRenderTaskSetTargetFrameBufferN(void)
+int UtcDaliRenderTaskSetFrameBufferN(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask::SetTargetFrameBuffer()");
+ tet_infoline("Testing RenderTask::SetFrameBuffer()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- FrameBufferImage newImage; // Empty handle
- task.SetTargetFrameBuffer( newImage );
- DALI_TEST_EQUALS( (bool)task.GetTargetFrameBuffer(), false, TEST_LOCATION );
+ RenderTask task = taskList.GetTask(0u);
+ FrameBuffer newFrameBuffer; // Empty handle
+ task.SetFrameBuffer(newFrameBuffer);
+ DALI_TEST_EQUALS((bool)task.GetFrameBuffer(), false, TEST_LOCATION);
END_TEST;
}
-int UtcDaliRenderTaskGetTargetFrameBufferP(void)
+int UtcDaliRenderTaskGetFrameBufferP(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask::GetTargetFrameBuffer()");
+ tet_infoline("Testing RenderTask::GetFrameBuffer()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask newTask = taskList.CreateTask();
- FrameBufferImage fb = FrameBufferImage::New(128, 128, Pixel::RGBA8888);
- newTask.SetTargetFrameBuffer( fb );
- DALI_TEST_EQUALS( newTask.GetTargetFrameBuffer(), fb, TEST_LOCATION );
+ RenderTask task = taskList.GetTask(0u);
+
+ FrameBuffer newFrameBuffer = FrameBuffer::New(1u, 1u, FrameBuffer::Attachment::NONE);
+ task.SetFrameBuffer(newFrameBuffer);
+ DALI_TEST_CHECK(task.GetFrameBuffer() == newFrameBuffer);
END_TEST;
}
-int UtcDaliRenderTaskGetTargetFrameBufferN(void)
+int UtcDaliRenderTaskGetFrameBufferN(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask::GetTargetFrameBuffer()");
+ tet_infoline("Testing RenderTask::GetFrameBuffer()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
// By default render-tasks do not render off-screen
- FrameBufferImage image = task.GetTargetFrameBuffer();
- DALI_TEST_CHECK( !image );
+ FrameBuffer frameBuffer = task.GetFrameBuffer();
+ DALI_TEST_CHECK(!frameBuffer);
END_TEST;
}
tet_infoline("Testing RenderTask::SetScreenToFrameBufferFunction()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
- task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
+ task.SetScreenToFrameBufferFunction(TestScreenToFrameBufferFunction);
- Vector2 coordinates( 5, 10 );
- Vector2 convertedCoordinates( 6, 12 ); // + Vector(1, 2)
+ Vector2 coordinates(5, 10);
+ Vector2 convertedCoordinates(6, 12); // + Vector(1, 2)
RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
- DALI_TEST_CHECK( func( coordinates ) );
- DALI_TEST_CHECK( coordinates == convertedCoordinates );
+ DALI_TEST_CHECK(func(coordinates));
+ DALI_TEST_CHECK(coordinates == convertedCoordinates);
- task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
+ task.SetScreenToFrameBufferFunction(RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION);
func = task.GetScreenToFrameBufferFunction();
- DALI_TEST_CHECK( func( coordinates ) );
+ DALI_TEST_CHECK(func(coordinates));
- task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
+ task.SetScreenToFrameBufferFunction(RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION);
func = task.GetScreenToFrameBufferFunction();
- DALI_TEST_CHECK( ! func( coordinates ) );
+ DALI_TEST_CHECK(!func(coordinates));
END_TEST;
}
RenderTask task; // Empty handle
try
{
- task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
+ task.SetScreenToFrameBufferFunction(TestScreenToFrameBufferFunction);
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::GetScreenToFrameBufferFunction()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
- Vector2 originalCoordinates( 5, 10 );
- Vector2 coordinates( 5, 10 );
+ Vector2 originalCoordinates(5, 10);
+ Vector2 coordinates(5, 10);
RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
- DALI_TEST_CHECK( !func( coordinates ) ); // conversion should fail by default
- DALI_TEST_CHECK( coordinates == originalCoordinates ); // coordinates should not be modified
+ DALI_TEST_CHECK(!func(coordinates)); // conversion should fail by default
+ DALI_TEST_CHECK(coordinates == originalCoordinates); // coordinates should not be modified
END_TEST;
}
try
{
RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
- func=func;
+ (void)func;
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorP(void)
{
TestApplication application;
tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor ");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask renderTask = taskList.CreateTask();
- Actor mappingActor = Actor::New();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask renderTask = taskList.CreateTask();
+ Actor mappingActor = Actor::New();
renderTask.SetScreenToFrameBufferMappingActor(mappingActor);
- DALI_TEST_EQUALS( mappingActor, renderTask.GetScreenToFrameBufferMappingActor(), TEST_LOCATION );
+ DALI_TEST_EQUALS(mappingActor, renderTask.GetScreenToFrameBufferMappingActor(), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorN(void)
{
TestApplication application;
Actor mappingActor;
task.SetScreenToFrameBufferMappingActor(mappingActor);
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
TestApplication application;
tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor with empty task handle");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask renderTask = taskList.CreateTask();
- Actor actor;
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask renderTask = taskList.CreateTask();
+ Actor actor;
renderTask.SetScreenToFrameBufferMappingActor(actor);
- DALI_TEST_EQUALS( (bool)renderTask.GetScreenToFrameBufferMappingActor(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS((bool)renderTask.GetScreenToFrameBufferMappingActor(), false, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing RenderTask::GetViewport() on default task");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- Viewport viewport = task.GetViewport();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
+ Viewport viewport = task.GetViewport();
// By default the viewport should match the stage width/height
- Vector2 stageSize = Stage::GetCurrent().GetSize();
- Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
- DALI_TEST_CHECK( viewport == expectedViewport );
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport expectedViewport(0, 0, stageSize.width, stageSize.height);
+ DALI_TEST_CHECK(viewport == expectedViewport);
END_TEST;
}
tet_infoline("Testing RenderTask::GetViewport() on new task");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask task = taskList.CreateTask();
- Viewport viewport = task.GetViewport();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.CreateTask();
+ Viewport viewport = task.GetViewport();
// By default the viewport should match the stage width/height
- Vector2 stageSize = Stage::GetCurrent().GetSize();
- Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
- DALI_TEST_CHECK( viewport == expectedViewport );
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport expectedViewport(0, 0, stageSize.width, stageSize.height);
+ DALI_TEST_CHECK(viewport == expectedViewport);
END_TEST;
}
try
{
Viewport viewport = task.GetViewport();
- viewport = viewport;
+ (void)viewport;
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliRenderTaskSetViewportP(void)
{
TestApplication application;
tet_infoline("Testing RenderTask::SetViewport()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- Vector2 stageSize = Stage::GetCurrent().GetSize();
- Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
- task.SetViewport( newViewport );
+ RenderTask task = taskList.GetTask(0u);
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport newViewport(0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f);
+ task.SetViewport(newViewport);
// Update (viewport is a property)
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( task.GetViewport() == newViewport );
+ DALI_TEST_CHECK(task.GetViewport() == newViewport);
END_TEST;
}
tet_infoline("Testing RenderTask::SetViewport()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
RenderTask task;
try
{
- Vector2 stageSize = Stage::GetCurrent().GetSize();
- Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
- task.SetViewport( newViewport );
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport newViewport(0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f);
+ task.SetViewport(newViewport);
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliRenderTaskSetViewportPosition(void)
{
TestApplication application;
tet_infoline("Testing RenderTask::SetViewportPosition()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Viewport viewport = task.GetViewport();
// By default the viewport should match the stage width/height
- Vector2 stageSize = Stage::GetCurrent().GetSize();
- Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
- DALI_TEST_CHECK( viewport == expectedViewport );
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport expectedViewport(0, 0, stageSize.width, stageSize.height);
+ DALI_TEST_CHECK(viewport == expectedViewport);
// 'Setter' test
Vector2 newPosition(25.0f, 50.0f);
- task.SetViewportPosition( newPosition );
+ task.SetViewportPosition(newPosition);
// Update (viewport is a property)
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportPosition(), newPosition, Math::MACHINE_EPSILON_1, TEST_LOCATION);
// Set by Property test
Vector2 newPosition2(32.0f, 32.0f);
- task.SetProperty( RenderTask::Property::VIEWPORT_POSITION, newPosition2 );
+ task.SetProperty(RenderTask::Property::VIEWPORT_POSITION, newPosition2);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition, TEST_LOCATION); // still the old position
// Update
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportPosition(), newPosition2, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition2, TEST_LOCATION);
- Vector2 newPosition3(64.0f, 0.0f);
+ Vector2 newPosition3(64.0f, 0.0f);
Animation animation = Animation::New(1.0f);
- animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_POSITION ), newPosition3, AlphaFunction::LINEAR );
+ animation.AnimateTo(Property(task, RenderTask::Property::VIEWPORT_POSITION), newPosition3, AlphaFunction::LINEAR);
+ animation.Play();
+
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition2, TEST_LOCATION);
+
+ // Perform 1000ms worth of updates at which point animation should have completed.
+ Wait(application, 1000);
+ DALI_TEST_EQUALS(task.GetCurrentViewportPosition(), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+
+ // Create another animation which animates by a certain value
+ const Vector2 newPosition4(75.0f, 45.0f);
+ const Vector2 relativePosition(newPosition4 - newPosition3);
+ animation = Animation::New(1.0f);
+ animation.AnimateBy(Property(task, RenderTask::Property::VIEWPORT_POSITION), relativePosition);
animation.Play();
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition3, TEST_LOCATION);
+
// Perform 1000ms worth of updates at which point animation should have completed.
Wait(application, 1000);
- DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportPosition(), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+
END_TEST;
}
tet_infoline("Testing RenderTask::SetViewportSize()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Viewport viewport = task.GetViewport();
// By default the viewport should match the stage width/height
- Vector2 stageSize = Stage::GetCurrent().GetSize();
- Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
- DALI_TEST_CHECK( viewport == expectedViewport );
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport expectedViewport(0, 0, stageSize.width, stageSize.height);
+ DALI_TEST_CHECK(viewport == expectedViewport);
Vector2 newSize(128.0f, 64.0f);
- task.SetViewportSize( newSize );
+ task.SetViewportSize(newSize);
// Update (viewport is a property)
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportSize(), newSize, Math::MACHINE_EPSILON_1, TEST_LOCATION);
// Set by Property test
Vector2 newSize2(50.0f, 50.0f);
- task.SetProperty( RenderTask::Property::VIEWPORT_SIZE, newSize2 );
+ task.SetProperty(RenderTask::Property::VIEWPORT_SIZE, newSize2);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize, TEST_LOCATION); // still the old position
// Update
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportSize(), newSize2, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize2, TEST_LOCATION);
- Vector2 newSize3(10.0f, 10.0f);
+ Vector2 newSize3(10.0f, 10.0f);
Animation animation = Animation::New(1.0f);
- animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_SIZE ), newSize3, AlphaFunction::LINEAR );
+ animation.AnimateTo(Property(task, RenderTask::Property::VIEWPORT_SIZE), newSize3, AlphaFunction::LINEAR);
+ animation.Play();
+
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize2, TEST_LOCATION);
+
+ // Perform 1000ms worth of updates at which point animation should have completed.
+ Wait(application, 1000);
+ DALI_TEST_EQUALS(task.GetCurrentViewportSize(), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+
+ // Create another animation which animates by a certain value
+ const Vector2 newSize4(75.0f, 45.0f);
+ const Vector2 relativeSize(newSize4 - newSize3);
+ animation = Animation::New(1.0f);
+ animation.AnimateBy(Property(task, RenderTask::Property::VIEWPORT_SIZE), relativeSize);
animation.Play();
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize3, TEST_LOCATION);
+
// Perform 1000ms worth of updates at which point animation should have completed.
Wait(application, 1000);
- DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportSize(), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing RenderTask::SetClearColor()");
- Vector4 testColor( 1.0f, 2.0f, 3.0f, 4.0f );
- Vector4 testColor2( 5.0f, 6.0f, 7.0f, 8.0f );
+ Vector4 testColor(1.0f, 2.0f, 3.0f, 4.0f);
+ Vector4 testColor2(5.0f, 6.0f, 7.0f, 8.0f);
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( task.GetClearColor() != testColor );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(task.GetClearColor() != testColor);
- task.SetClearColor( testColor );
+ task.SetClearColor(testColor);
// Wait a frame.
Wait(application);
- DALI_TEST_EQUALS( task.GetClearColor(), testColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetClearColor(), testColor, TEST_LOCATION);
- task.SetProperty( RenderTask::Property::CLEAR_COLOR, testColor2 );
+ task.SetProperty(RenderTask::Property::CLEAR_COLOR, testColor2);
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), testColor2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), testColor, TEST_LOCATION); // still the old color
// Wait a frame.
Wait(application);
- DALI_TEST_EQUALS( task.GetClearColor(), testColor2, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetClearColor(), testColor2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), testColor2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), testColor2, TEST_LOCATION);
+
+ Vector4 newColor3(10.0f, 10.0f, 20.0f, 30.0f);
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(task, RenderTask::Property::CLEAR_COLOR), newColor3, AlphaFunction::LINEAR);
+ animation.Play();
+
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), testColor2, TEST_LOCATION);
+
+ // Perform 1000ms worth of updates at which point animation should have completed.
+ Wait(application, 1000);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+
+ // Create another animation which animates by a certain value
+ const Vector4 newColor4(0.45f, 0.35f, 0.25f, 0.1f);
+ const Vector4 relativeColor(newColor4 - newColor3);
+ animation = Animation::New(1.0f);
+ animation.AnimateBy(Property(task, RenderTask::Property::CLEAR_COLOR), relativeColor);
+ animation.Play();
+
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor3, Math::MACHINE_EPSILON_10, TEST_LOCATION);
+
+ // Perform 1000ms worth of updates at which point animation should have completed.
+ Wait(application, 1000);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION);
+
END_TEST;
}
RenderTask task;
try
{
- task.SetClearColor( Vector4::ZERO );
+ task.SetClearColor(Vector4::ZERO);
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::GetClearColor()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_EQUALS( task.GetClearColor(), RenderTask::DEFAULT_CLEAR_COLOR, TEST_LOCATION );
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_EQUALS(task.GetClearColor(), RenderTask::DEFAULT_CLEAR_COLOR, TEST_LOCATION);
END_TEST;
}
try
{
Vector4 color = task.GetClearColor();
- color = color;
+ (void)color;
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::SetClearEnabled()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( !task.GetClearEnabled() ); // defaults to false
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(task.GetClearEnabled()); // defaults to true
- task.SetClearEnabled( true );
- DALI_TEST_EQUALS( task.GetClearEnabled(), true, TEST_LOCATION );
+ task.SetClearEnabled(false);
+ DALI_TEST_EQUALS(task.GetClearEnabled(), false, TEST_LOCATION);
- task.SetClearEnabled( false );
- DALI_TEST_EQUALS( task.GetClearEnabled(), false, TEST_LOCATION );
+ task.SetClearEnabled(true);
+ DALI_TEST_EQUALS(task.GetClearEnabled(), true, TEST_LOCATION);
END_TEST;
}
{
task.SetClearEnabled(true);
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::GetClearEnabled()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( !task.GetClearEnabled() ); // defaults to false
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(task.GetClearEnabled()); // defaults to true
END_TEST;
}
-
int UtcDaliRenderTaskGetClearEnabledN(void)
{
TestApplication application;
try
{
bool x = task.GetClearEnabled();
- x=x;
+ (void)x;
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::SetCullMode()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_EQUALS( task.GetCullMode(), true, TEST_LOCATION );
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_EQUALS(task.GetCullMode(), true, TEST_LOCATION);
- task.SetCullMode( false );
+ task.SetCullMode(false);
- DALI_TEST_EQUALS( task.GetCullMode(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCullMode(), false, TEST_LOCATION);
END_TEST;
}
RenderTask task;
try
{
- task.SetCullMode( false );
+ task.SetCullMode(false);
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::GetCullMode()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_EQUALS( task.GetCullMode(), true, TEST_LOCATION );
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_EQUALS(task.GetCullMode(), true, TEST_LOCATION);
END_TEST;
}
try
{
bool x = task.GetCullMode();
- x=x;
+ (void)x;
}
- catch (Dali::DaliException(e))
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliRenderTaskSetRefreshRate(void)
{
TestApplication application;
tet_infoline("Testing RenderTask::SetRefreshRate()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// By default tasks will be processed every frame
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(RenderTask::REFRESH_ALWAYS == task.GetRefreshRate());
- task.SetRefreshRate( 2u ); // every-other frame
- DALI_TEST_CHECK( 2u == task.GetRefreshRate() );
+ task.SetRefreshRate(2u); // every-other frame
+ DALI_TEST_CHECK(2u == task.GetRefreshRate());
- task.SetRefreshRate( RenderTask::REFRESH_ALWAYS );
- DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
+ task.SetRefreshRate(RenderTask::REFRESH_ALWAYS);
+ DALI_TEST_CHECK(RenderTask::REFRESH_ALWAYS == task.GetRefreshRate());
END_TEST;
}
tet_infoline("Testing RenderTask::GetRefreshRate()");
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// By default tasks will be processed every frame
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(RenderTask::REFRESH_ALWAYS == task.GetRefreshRate());
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == newTask.GetRefreshRate() );
+ DALI_TEST_CHECK(RenderTask::REFRESH_ALWAYS == newTask.GetRefreshRate());
END_TEST;
}
tet_infoline("Testing RenderTask::SignalFinished()");
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ auto& sync = application.GetGraphicsSyncImpl();
CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
+ application.GetScene().Add(offscreenCameraActor);
- BufferImage image = BufferImage::New( 10, 10 );
- image.Update();
- ImageActor rootActor = ImageActor::New( image );
- rootActor.SetSize( 10, 10 );
- Stage::GetCurrent().Add( rootActor );
+ Texture image = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10);
+ Actor rootActor = CreateRenderableActor(image);
+ rootActor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+ application.GetScene().Add(rootActor);
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
- FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
+ Texture frameBufferTexture = Texture::New(*testNativeImagePtr);
+ FrameBuffer frameBuffer = FrameBuffer::New(frameBufferTexture.GetWidth(), frameBufferTexture.GetHeight());
+ frameBuffer.AttachColorTexture(frameBufferTexture);
RenderTask newTask = taskList.CreateTask();
- newTask.SetCameraActor( offscreenCameraActor );
- newTask.SetSourceActor( rootActor );
- newTask.SetInputEnabled( false );
- newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
- newTask.SetClearEnabled( true );
- newTask.SetExclusive( true );
- newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
- newTask.SetTargetFrameBuffer( frameBufferImage );
-
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ newTask.SetCameraActor(offscreenCameraActor);
+ newTask.SetSourceActor(rootActor);
+ newTask.SetInputEnabled(false);
+ newTask.SetClearColor(Vector4(0.f, 0.f, 0.f, 0.f));
+ newTask.SetClearEnabled(true);
+ newTask.SetExclusive(true);
+ newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
+ newTask.SetFrameBuffer(frameBuffer);
+ newTask.SetProperty(RenderTask::Property::REQUIRES_SYNC, true);
+
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
// Flush the queue and render.
application.SendNotification();
application.Render();
application.SendNotification();
- DALI_TEST_CHECK( !finished );
+ DALI_TEST_CHECK(!finished);
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ DALI_TEST_CHECK(lastSyncObj != NULL);
application.Render();
- DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
+ DALI_TEST_EQUALS((Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION);
application.SendNotification();
- DALI_TEST_CHECK( !finished );
+ DALI_TEST_CHECK(!finished);
application.Render();
- DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
+ DALI_TEST_EQUALS((Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION);
application.SendNotification();
- DALI_TEST_CHECK( ! finished );
+ DALI_TEST_CHECK(!finished);
- sync.SetObjectSynced( lastSyncObj, true );
+ sync.SetObjectSynced(lastSyncObj, true);
application.Render();
application.SendNotification();
- DALI_TEST_CHECK( !finished );
+ DALI_TEST_CHECK(!finished);
application.Render();
application.SendNotification();
- DALI_TEST_CHECK( finished );
- finished = false;
+ DALI_TEST_CHECK(finished);
- DALI_TEST_EQUALS( application.GetUpdateStatus(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(application.GetUpdateStatus(), 0, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRenderTaskContinuous01(void)
{
TestApplication application;
tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not staged)\nPOST:continuous renders, no Finished signal");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
application.SendNotification();
// START PROCESS/RENDER Input, Expected Input, Expected, KeepUpdating
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, false, __LINE__));
application.GetPlatform().ClearReadyResources();
// ADD SOURCE ACTOR TO STAGE - expect continuous renders to start, no finished signal
- Stage::GetCurrent().Add(secondRootActor);
+ application.GetScene().Add(secondRootActor);
application.SendNotification();
// CONTINUE PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
END_TEST;
}
-
int UtcDaliRenderTaskContinuous02(void)
{
TestApplication application;
tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not visible)\nPOST:continuous renders, no Finished signal");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- Stage::GetCurrent().Add(secondRootActor);
- secondRootActor.SetVisible(false);
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(secondRootActor);
+ secondRootActor.SetProperty(Actor::Property::VISIBLE, false);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
// START PROCESS/RENDER Input, Expected Input, Expected, KeepUpdating
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, false, __LINE__));
application.GetPlatform().ClearReadyResources();
// MAKE SOURCE ACTOR VISIBLE - expect continuous renders to start, no finished signal
- secondRootActor.SetVisible(true);
+ secondRootActor.SetProperty(Actor::Property::VISIBLE, true);
application.SendNotification();
// CONTINUE PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
END_TEST;
}
tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (camera actor not staged)\nPOST:continuous renders, no Finished signal");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- Stage::GetCurrent().Add(secondRootActor);
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
// START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, false, __LINE__));
application.GetPlatform().ClearReadyResources();
// ADD CAMERA ACTOR TO STAGE - expect continuous renders to start, no finished signal
- Stage::GetCurrent().Add( offscreenCameraActor );
+ application.GetScene().Add(offscreenCameraActor);
application.SendNotification();
// CONTINUE PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
END_TEST;
}
-
int UtcDaliRenderTaskContinuous04(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: Resource not ready\nPOST:continuous renders, no Finished signal");
+ tet_infoline("Testing RenderTask Render Continuous using loaded image");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- Stage::GetCurrent().Add(secondRootActor);
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
// START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
+ END_TEST;
+}
+
+int UtcDaliRenderTaskOnce01(void)
+{
+ TestApplication application;
+
+ tet_infoline("Testing RenderTask Render Once GlSync, using loaded image");
+
+ // SETUP AN OFFSCREEN RENDER TASK
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ auto& sync = application.GetGraphicsSyncImpl();
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ drawTrace.Enable(true);
+
+ Actor rootActor = Actor::New();
+ application.GetScene().Add(rootActor);
+
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+
+ application.GetScene().Add(secondRootActor);
+
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
+ application.SendNotification();
+
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
- // FINISH RESOURCE LOADING - expect 'continuous' renders to start, no finished signal
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ DALI_TEST_CHECK(lastSyncObj != NULL);
+ sync.SetObjectSynced(lastSyncObj, true);
+
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
-int UtcDaliRenderTaskContinous05(void)
+int UtcDaliRenderTaskOnce02(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Continuous using Mesh which accesses texture through sampler with loading image\n"
- "PRE: Resource not ready\nPOST:continuous renders, no Finished signal");
+ tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loaded image.\n");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ auto& sync = application.GetGraphicsSyncImpl();
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- Material material = CreateMaterial();
- Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- material.AddTexture( image, "sTexture" );
+ Shader shader = CreateShader();
+ Texture image = CreateTexture();
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New(geometry, material);
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor secondRootActor = Actor::New();
secondRootActor.AddRenderer(renderer);
- secondRootActor.SetSize(100, 100);
- Stage::GetCurrent().Add(secondRootActor);
+ secondRootActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
- // FINISH RESOURCE LOADING - expect 'continuous' renders to start, no finished signal
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ DALI_TEST_CHECK(lastSyncObj != NULL);
+ sync.SetObjectSynced(lastSyncObj, true);
+
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
-
-int UtcDaliRenderTaskOnce01(void)
+int UtcDaliRenderTaskOnce03(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once GlSync, using loading image\nPRE: Resources not ready, Source not visible\nPOST: Finished signal sent once only");
+ tet_infoline("Testing RenderTask Render Once GlSync, using loaded image. Switch from render always after ready to render once\n");
- // SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ auto& sync = application.GetGraphicsSyncImpl();
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
-
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
+ application.GetScene().Add(rootActor);
- Stage::GetCurrent().Add(secondRootActor);
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
- // MAKE SOURCE VISIBLE
- secondRootActor.SetVisible(true);
+ newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ // drawn sig finished Keep updating
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
- // FINISH RESOURCE LOADING - expect no rendering yet
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ DALI_TEST_CHECK(lastSyncObj != NULL);
+ sync.SetObjectSynced(lastSyncObj, true);
+
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- application.GetPlatform().ClearReadyResources();
- sync.SetObjectSynced( lastSyncObj, true );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
END_TEST;
}
-int UtcDaliRenderTaskOnce02(void)
+int UtcDaliRenderTaskOnce04(void)
{
TestApplication application;
-
- tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loading image.\n"
- "PRE: Resources not ready\nPOST: Finished signal sent once only");
+ tet_infoline(
+ "Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loaded image.\n"
+ "Switch from render always after ready to render once\n");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ auto& sync = application.GetGraphicsSyncImpl();
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- Material material = CreateMaterial();
- Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- material.AddTexture( image, "sTexture" );
+ Shader shader = CreateShader();
+ Texture image = CreateTexture();
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New(geometry, material);
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor secondRootActor = Actor::New();
secondRootActor.AddRenderer(renderer);
- secondRootActor.SetSize(100, 100);
- Stage::GetCurrent().Add(secondRootActor);
+ secondRootActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
+
+ newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
+ application.SendNotification();
+ // FAILS drawn sig finished Keep updating
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
- // FINISH RESOURCE LOADING - expect no rendering yet
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ DALI_TEST_CHECK(lastSyncObj != NULL);
+ sync.SetObjectSynced(lastSyncObj, true);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- application.GetPlatform().ClearReadyResources();
- sync.SetObjectSynced( lastSyncObj, true );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
- END_TEST;
+ END_TEST;
}
-int UtcDaliRenderTaskOnce03(void)
+int UtcDaliRenderTaskOnceNoSync01(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once GlSync, using loading image. Switch from render always after ready to render once\n"
- "PRE: Render task ready, Image not loaded\n"
- "POST: Finished signal sent only once");
+ tet_infoline("Testing RenderTask Render Once, \nPRE: Resources ready\nPOST: Finished signal sent once only");
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ // SETUP AN OFFSCREEN RENDER TASK
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- Stage::GetCurrent().Add(secondRootActor);
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
-
- // FINISH RESOURCE LOADING
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
- application.GetPlatform().ClearReadyResources();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
-
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification(); // Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
-
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- sync.SetObjectSynced( lastSyncObj, true );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
-
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
-
-int UtcDaliRenderTaskOnce04(void)
+int UtcDaliRenderTaskOnceNoSync02(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loading image.\n"
- "Switch from render always after ready to render once\n"
- "PRE: Render task ready, Image not loaded\n"
- "POST: Finished signal sent only once");
+ tet_infoline(
+ "Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loaded image.\n"
+ "PRE: Resources ready\nPOST: Finished signal sent once only");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- Material material = CreateMaterial();
- Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- material.AddTexture( image, "sTexture" );
+ Shader shader = CreateShader();
+ Texture image = CreateTexture();
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New(geometry, material);
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor secondRootActor = Actor::New();
secondRootActor.AddRenderer(renderer);
- secondRootActor.SetSize(100, 100);
- Stage::GetCurrent().Add(secondRootActor);
+ secondRootActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
-
- // FINISH RESOURCE LOADING
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
application.GetPlatform().ClearReadyResources();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
-
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification(); // Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
-
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- sync.SetObjectSynced( lastSyncObj, true );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
-int UtcDaliRenderTaskOnce05(void)
+int UtcDaliRenderTaskOnceNoSync03(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once GlSync\n"
- "Switch from Render always after ready to render once with resources unready\n"
- "PRE: Everything ready to render\n"
- "POST: Finished signal sent once");
+ tet_infoline(
+ "Testing RenderTask Render Once, using loaded image. Switch from render always after ready to render once\n"
+ "PRE: Render task ready, Image loaded\n"
+ "POST: Finished signal sent only once");
// SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- Stage::GetCurrent().Add(secondRootActor);
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
- // CHANGE TO RENDER ONCE
newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
application.SendNotification(); // Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
-
- // FINISH RESOURCE LOADING
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
- application.GetPlatform().ClearReadyResources();
-
- sync.SetObjectSynced( lastSyncObj, true );
-
- // Expect: No draw - we've just drawn our render task once, above. No finished signal -
- // we won't read the gl sync until the next frame. Continue rendering - we're waiting for
- // the sync
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
-
- // Expect: 1 final draw - this Update doesn't update the scene, hence render instructions
- // from last frame but 1 are still present.
- // Finished signal should be true - we've just done the sync.
- // Should now stop rendering and updating - nothing left to do.
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, true, false, __LINE__ ) );
-
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
-#if 0
-//int UtcDaliRenderTaskOnce06(void)
+int UtcDaliRenderTaskOnceNoSync04(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once GlSync\n"
- "During RenderOnce, make ready resources unready before sending first finished signal\n"
- "PRE: Everything ready.\n"
- "POST: Finished signal sent only once");
+ tet_infoline(
+ "Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loading image.\n"
+ "Switch from render always after ready to render once\n"
+ "PRE: Render task ready, Image not loaded\n"
+ "POST: Finished signal sent only once");
// SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- application.Render();
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- Stage::GetCurrent().Add(secondRootActor);
- application.GetPlatform().ClearReadyResources();
+ Shader shader = CreateShader();
+ Texture image = CreateTexture();
+ TextureSet textureSet = CreateTextureSet(image);
+
+ Geometry geometry = CreateQuadGeometry();
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
+ Actor secondRootActor = Actor::New();
+ secondRootActor.AddRenderer(renderer);
+ secondRootActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
+ auto& sync = application.GetGraphicsSyncImpl();
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ DALI_TEST_CHECK(lastSyncObj == NULL);
- // CHANGE TO RENDER ONCE, RESOURCES BECOME NOT READY
newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
-
- // Doesn't work...
- ReloadImage(application, secondRootActor.GetImage());
application.SendNotification(); // Input, Expected Input, Expected
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_EQUALS( secondRootActor.GetImage().GetLoadingState(), Dali::ResourceLoading, TEST_LOCATION);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
-
- // FINISH RESOURCE LOADING
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- application.GetPlatform().ClearReadyResources();
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
-
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- sync.SetObjectSynced( lastSyncObj, true );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, true, __LINE__ ) );
+ lastSyncObj = sync.GetLastSyncObject();
+ DALI_TEST_CHECK(lastSyncObj == NULL);
- // Finished rendering - expect no more renders, no more signals:
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
END_TEST;
}
-#endif
-int UtcDaliRenderTaskOnce07(void)
+int UtcDaliRenderTaskOnceNoSync05(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once GLSync\n"
- "Render once, Second call to SetRefreshRate(ONCE) triggers only one more finished signal\n"
- "PRE: Everything ready\n"
- "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
+ tet_infoline(
+ "Testing RenderTask Render Once\n"
+ "SetRefreshRate(ONCE), resource load failed, completes render task.\n"
+ "PRE: resources failed to load\n"
+ "POST: No finished signal sent.");
// SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
-
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- application.Render();
- application.GetPlatform().ClearReadyResources();
+ application.GetScene().Add(rootActor);
- Stage::GetCurrent().Add(secondRootActor);
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ // START PROCESS/RENDER Input, Expected Input, Expected
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
// CHANGE TO RENDER ONCE,
newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
-
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- sync.SetObjectSynced( lastSyncObj, true );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
-
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- sync.SetObjectSynced( lastSyncObj, true );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
END_TEST;
}
-int UtcDaliRenderTaskOnce08(void)
+int UtcDaliRenderTaskOnceChain01(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once GLSync\n"
- "Render once, Call to SetRefreshRate(ONCE) in Finished signal callback triggers "
- "another render & another finished signal\n"
- "PRE: Everything ready\n"
- "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
-
+ tet_infoline(
+ "Testing RenderTask Render Once Chained render tasks\n"
+ "SetRefreshRate(ONCE), resource load completes, both render tasks render.\n"
+ "PRE: resources ready\n"
+ "POST: 2 finished signals sent.");
// SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- sync.GetTrace().Enable(true);
drawTrace.Enable(true);
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
-
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- application.Render();
- application.GetPlatform().ClearReadyResources();
-
- Stage::GetCurrent().Add(secondRootActor);
-
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, /*GL-SYNC*/ true);
- bool finished = false;
-
- ConnectionTracker connectionTracker;
- RenderTaskFinishedRenderAgain renderTaskFinishedRenderAgain( finished );
- newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinishedRenderAgain );
+ Actor defaultRootActor = Actor::New(); // Root for default RT
+ application.GetScene().Add(defaultRootActor);
- application.SendNotification();
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+ Actor firstRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(firstRootActor);
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj == NULL );
- DALI_TEST_EQUALS( sync.GetTrace().CountMethod( "CreateSyncObject" ), 0, TEST_LOCATION );
+ // first render task
+ RenderTask firstTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, firstRootActor, RenderTask::REFRESH_ONCE, false);
+ bool firstFinished = false;
+ RenderTaskFinished renderTask1Finished(firstFinished);
+ firstTask.FinishedSignal().Connect(&application, renderTask1Finished);
+ // Second render task
+ FrameBuffer fbo = firstTask.GetFrameBuffer();
+ Actor secondRootActor = CreateRenderableActor(fbo.GetColorTexture());
+ application.GetScene().Add(secondRootActor);
+ RenderTask secondTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
+ bool secondFinished = false;
+ RenderTaskFinished renderTask2Finished(secondFinished);
+ secondTask.FinishedSignal().Connect(&application, renderTask2Finished);
- // CHANGE TO RENDER ONCE,
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
- DALI_TEST_EQUALS( sync.GetNumberOfSyncObjects(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( sync.GetTrace().CountMethod( "CreateSyncObject" ), 1, TEST_LOCATION );
-
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ //Both render tasks are executed.
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, firstFinished, false, true, __LINE__));
+ DALI_TEST_CHECK(firstFinished == false);
+ DALI_TEST_CHECK(secondFinished == false);
- DALI_TEST_EQUALS( sync.GetNumberOfSyncObjects(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( sync.GetTrace().CountMethod( "CreateSyncObject" ), 1, TEST_LOCATION );
+ //Nothing else to render and both render task should have finished now
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, firstFinished, true, false, __LINE__));
+ DALI_TEST_CHECK(firstFinished == true);
+ DALI_TEST_CHECK(secondFinished == true);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
-
- DALI_TEST_EQUALS( sync.GetNumberOfSyncObjects(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( sync.GetTrace().CountMethod( "CreateSyncObject" ), 1, TEST_LOCATION );
+ END_TEST;
+}
- sync.SetObjectSynced( lastSyncObj, true );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
- application.SendNotification();
+int UtcDaliRenderTaskProperties(void)
+{
+ TestApplication application;
- // Expect SetRefreshRate to have been called again
- // Prevent next finished signal calling refresh once again
- RenderTaskFinished renderTaskFinished( finished );
- connectionTracker.DisconnectAll();
- newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinished );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
+ RenderTask task = application.GetScene().GetRenderTaskList().CreateTask();
- sync.SetObjectSynced( lastSyncObj, true );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ Property::IndexContainer indices;
+ task.GetPropertyIndices(indices);
+ DALI_TEST_CHECK(indices.Size());
+ DALI_TEST_EQUALS(indices.Size(), task.GetPropertyCount(), TEST_LOCATION);
END_TEST;
}
-
-int UtcDaliRenderTaskOnce09(void)
+int UtcDaliRenderTaskFinishInvisibleSourceActor(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once GlSync\n"
- "SetRefreshRate(ONCE) again before first finished signal has been sent.\n"
- "PRE: resources ready\n"
- "POST: Only 1 finished signal sent.");
-
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
+ tet_infoline("Testing RenderTask::FinishInvisibleSourceActor()");
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ auto& sync = application.GetGraphicsSyncImpl();
CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- application.Render();
- application.GetPlatform().ClearReadyResources();
- Stage::GetCurrent().Add(secondRootActor);
+ application.GetScene().Add(offscreenCameraActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
- application.SendNotification();
+ Texture image = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10);
+ Actor rootActor = CreateRenderableActor(image);
+ rootActor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+ rootActor.SetProperty(Actor::Property::VISIBLE, false);
+ application.GetScene().Add(rootActor);
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
+ Texture frameBufferTexture = Texture::New(*testNativeImagePtr);
+ FrameBuffer frameBuffer = FrameBuffer::New(frameBufferTexture.GetWidth(), frameBufferTexture.GetHeight());
+ frameBuffer.AttachColorTexture(frameBufferTexture);
- // CHANGE TO RENDER ONCE,
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
+ // Flush all outstanding messages
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ application.Render();
+ RenderTask newTask = taskList.CreateTask();
+ newTask.SetCameraActor(offscreenCameraActor);
+ newTask.SetSourceActor(rootActor);
+ newTask.SetInputEnabled(false);
+ newTask.SetClearColor(Vector4(0.f, 0.f, 0.f, 0.f));
+ newTask.SetClearEnabled(true);
+ newTask.SetExclusive(true);
newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
+ newTask.SetFrameBuffer(frameBuffer);
+ newTask.SetProperty(RenderTask::Property::REQUIRES_SYNC, true);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- sync.SetObjectSynced( lastSyncObj, true );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
-
- END_TEST;
-}
+ // Framebuffer doesn't actually get created until Connected, i.e. by previous line
-int UtcDaliRenderTaskOnce10(void)
-{
- TestApplication application;
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
- tet_infoline("Testing RenderTask Render Once GlSync\n"
- "SetRefreshRate(ONCE), resource load failed completes render task.\n"
- "PRE: resources not ready\n"
- "POST: Only 1 finished signal sent.");
+ // Flush the queue and render.
+ application.SendNotification();
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
+ // 1 render to process render task, then wait for sync before finished msg is sent
+ // from update to the event thread.
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.Render();
+ application.SendNotification();
+ DALI_TEST_CHECK(!finished);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Stage::GetCurrent().Add(secondRootActor);
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ DALI_TEST_CHECK(lastSyncObj != NULL);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ application.Render();
+ DALI_TEST_EQUALS((Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION);
application.SendNotification();
+ DALI_TEST_CHECK(!finished);
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
-
- // CHANGE TO RENDER ONCE,
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
+ application.Render();
+ DALI_TEST_EQUALS((Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(!finished);
- tet_printf(" FailImageLoad\n");
+ sync.SetObjectSynced(lastSyncObj, true);
- FailImageLoad(application, imageRequestId); // Need to run Update again for this to complete
+ application.Render();
+ application.SendNotification();
+ DALI_TEST_CHECK(!finished);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) ); // nothing to draw
+ application.Render();
application.SendNotification();
+ DALI_TEST_CHECK(finished);
+ finished = false;
- // load is now failed so there's nothing more to render in the render task
- // Expect finished signal, as all resources are complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ application.Render(); // Double check no more finished signal
+ application.SendNotification();
+ DALI_TEST_CHECK(!finished);
END_TEST;
}
-int UtcDaliRenderTaskOnceNoSync01(void)
+int UtcDaliRenderTaskFinishMissingImage(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once, using loading image\nPRE: Resources not ready, Source not visible\nPOST: Finished signal sent once only");
+ // Previously we had bugs where not having a resource ID would cause render-tasks to wait forever
+ tet_infoline("Testing RenderTask::SignalFinished() when an Actor has no Image set");
- // SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
+ Integration::Scene stage = application.GetScene();
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ Texture image = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10);
+ Actor rootActor = CreateRenderableActor(image);
+ rootActor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+ stage.Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
+ Actor actorWithMissingImage = CreateRenderableActor(Texture());
+ actorWithMissingImage.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+ stage.Add(actorWithMissingImage);
+
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask newTask = taskList.CreateTask();
+ newTask.SetInputEnabled(false);
+ newTask.SetClearColor(Vector4(0.f, 0.f, 0.f, 0.f));
+ newTask.SetClearEnabled(true);
+ newTask.SetExclusive(true);
+ newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- Stage::GetCurrent().Add(secondRootActor);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ // 1 render to process render task, then 1 before finished msg is sent from update to the event thread.
application.SendNotification();
+ application.Render();
+ application.Render();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ application.SendNotification();
+ DALI_TEST_CHECK(finished);
- // FINISH RESOURCE LOADING - expect immediate rendering yet
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- application.GetPlatform().ClearReadyResources();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
END_TEST;
}
-int UtcDaliRenderTaskOnceNoSync02(void)
+int UtcDaliRenderTaskWorldToViewport(void)
{
- TestApplication application;
+ TestApplication application(400u, 400u); // square surface
- tet_infoline("Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loading image.\n"
- "PRE: Resources not ready\nPOST: Finished signal sent once only");
- // SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0, 0.0, 0.0));
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5, 0.5, 0.5));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, Vector3(0.5, 0.5, 0.5));
- Material material = CreateMaterial();
- Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- material.AddTexture(image, "sTexture" );
+ application.GetScene().Add(actor);
- Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New(geometry, material);
- Actor secondRootActor = Actor::New();
- secondRootActor.AddRenderer(renderer);
- secondRootActor.SetSize(100, 100);
- Stage::GetCurrent().Add(secondRootActor);
+ application.SendNotification();
+ application.Render();
+ application.SendNotification();
+
+ RenderTask task = taskList.GetTask(0u);
+
+ CameraActor camera = task.GetCameraActor();
+
+ Vector2 screenSize = task.GetCurrentViewportSize();
+
+ float screenX = 0.0;
+ float screenY = 0.0;
+
+ bool ok = task.WorldToViewport(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), screenX, screenY);
+ DALI_TEST_CHECK(ok == true);
+
+ DALI_TEST_EQUALS(screenX, screenSize.x / 2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenY, screenSize.y / 2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+
+ Actor actor2 = Actor::New();
+ float actor2Size = 100.f;
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(actor2Size, actor2Size));
+ actor2.SetProperty(Actor::Property::POSITION, Vector3(0.0, 0.0, 0.0));
+ actor2.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5, 0.5, 0.0));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, Vector3(0.5, 0.5, 0.0));
+ application.GetScene().Add(actor2);
+ actor2.Add(actor);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0, 0, 0));
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ application.SendNotification();
+ application.Render();
application.SendNotification();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ ok = task.WorldToViewport(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), screenX, screenY);
+ DALI_TEST_CHECK(ok == true);
- // FINISH RESOURCE LOADING - expect immediate rendering yet
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- application.GetPlatform().ClearReadyResources();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_EQUALS(screenX, screenSize.x / 2 - actor2Size / 2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenY, screenSize.y / 2 - actor2Size / 2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
END_TEST;
}
-int UtcDaliRenderTaskOnceNoSync03(void)
+int UtcDaliRenderTaskViewportToLocal(void)
{
TestApplication application;
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(10.0f, 10.0f));
+ application.GetScene().Add(actor);
- tet_infoline("Testing RenderTask Render Once, using loading image. Switch from render always after ready to render once\n"
- "PRE: Render task ready, Image not loaded\n"
- "POST: Finished signal sent only once");
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+ application.SendNotification();
+ application.Render();
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ float localX;
+ float localY;
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- Stage::GetCurrent().Add(secondRootActor);
+ float rtLocalX;
+ float rtLocalY;
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
- application.SendNotification();
+ float screenX = 50.0f;
+ float screenY = 50.0f;
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(actor.ScreenToLocal(localX, localY, screenX, screenY));
- // FINISH RESOURCE LOADING
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
- application.GetPlatform().ClearReadyResources();
+ DALI_TEST_CHECK(task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY));
+
+ DALI_TEST_EQUALS(localX, rtLocalX, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(localY, rtLocalY, 0.01f, TEST_LOCATION);
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification(); // Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
END_TEST;
}
-int UtcDaliRenderTaskOnceNoSync04(void)
+int UtcDaliRenderTaskOffscreenViewportToLocal(void)
{
TestApplication application;
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(10.0f, 10.0f));
+ application.GetScene().Add(actor);
- tet_infoline("Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loading image.\n"
- "Switch from render always after ready to render once\n"
- "PRE: Render task ready, Image not loaded\n"
- "POST: Finished signal sent only once");
-
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
-
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
-
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
-
- Material material = CreateMaterial();
- Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- material.AddTexture( image, "sTexture" );
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.CreateTask();
- Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New(geometry, material);
- Actor secondRootActor = Actor::New();
- secondRootActor.AddRenderer(renderer);
- secondRootActor.SetSize(100, 100);
- Stage::GetCurrent().Add(secondRootActor);
+ FrameBuffer newFrameBuffer = FrameBuffer::New(10, 10);
+ task.SetFrameBuffer(newFrameBuffer);
+ task.SetSourceActor(actor);
+ task.SetScreenToFrameBufferMappingActor(actor);
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+ task.SetCameraActor(offscreenCameraActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
application.SendNotification();
+ application.Render();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ float localX;
+ float localY;
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj == NULL );
+ float rtLocalX;
+ float rtLocalY;
- // FINISH RESOURCE LOADING
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
- application.GetPlatform().ClearReadyResources();
+ float screenX = 50.0f;
+ float screenY = 50.0f;
- lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj == NULL );
+ DALI_TEST_CHECK(actor.ScreenToLocal(localX, localY, screenX, screenY));
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification(); // Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY));
- lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj == NULL );
+ DALI_TEST_EQUALS(localX, rtLocalX, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(localY, rtLocalY, 0.01f, TEST_LOCATION);
END_TEST;
}
-int UtcDaliRenderTaskOnceNoSync05(void)
+int UtcDaliRenderTaskRequiresSync(void)
{
TestApplication application;
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- tet_infoline("Testing RenderTask Render Once\n"
- "Switch from Render always after ready to render once with resources unready\n"
- "PRE: Everything ready to render\n"
- "POST: Finished signal sent once");
-
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
-
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
-
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- Stage::GetCurrent().Add(secondRootActor);
-
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
- application.SendNotification();
+ RenderTask newTask = taskList.CreateTask();
+ newTask.SetProperty(RenderTask::Property::REQUIRES_SYNC, false);
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj == NULL );
+ DALI_TEST_EQUALS(newTask.GetProperty<bool>(RenderTask::Property::REQUIRES_SYNC), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(newTask.GetCurrentProperty<bool>(RenderTask::Property::REQUIRES_SYNC), false, TEST_LOCATION);
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ newTask.SetProperty(RenderTask::Property::REQUIRES_SYNC, true);
- // CHANGE TO RENDER ONCE
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification(); // Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ DALI_TEST_EQUALS(newTask.GetProperty<bool>(RenderTask::Property::REQUIRES_SYNC), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(newTask.GetCurrentProperty<bool>(RenderTask::Property::REQUIRES_SYNC), true, TEST_LOCATION);
- // FINISH RESOURCE LOADING
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- application.GetPlatform().ClearReadyResources();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
END_TEST;
}
-#if 0
-//int UtcDaliRenderTaskOnceNoSync06(void)
+int UtcDaliRenderTaskSetClearEnabled(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once\n"
- "During RenderOnce, make ready resources unready before sending first finished signal\n"
- "PRE: Everything ready.\n"
- "POST: Finished signal sent only once");
+ tet_infoline("UtcDaliRenderTaskSetClearEnabled");
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+
+ Actor renderableActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(renderableActor);
Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- application.Render();
- application.GetPlatform().ClearReadyResources();
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+
+ Actor sourceActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(sourceActor);
+
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, sourceActor, RenderTask::REFRESH_ALWAYS, false);
- Stage::GetCurrent().Add(secondRootActor);
+ DALI_TEST_EQUALS(gl.GetClearCountCalled(), 0, TEST_LOCATION);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
application.SendNotification();
+ application.Render();
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ // glClear should be called twice - default task and the new task.
+ DALI_TEST_EQUALS(gl.GetClearCountCalled(), 2, TEST_LOCATION);
- // CHANGE TO RENDER ONCE, RESOURCES BECOME NOT READY
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
+ newTask.SetClearEnabled(false);
- // Doesn't work...
- ReloadImage(application, secondRootActor.GetImage());
- application.SendNotification(); // Input, Expected Input, Expected
+ application.SendNotification();
+ application.Render();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_EQUALS( secondRootActor.GetImage().GetLoadingState(), Dali::ResourceLoading, TEST_LOCATION);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+ // The count should increase by 1 - default task only.
+ DALI_TEST_EQUALS(gl.GetClearCountCalled(), 3, TEST_LOCATION);
- // FINISH RESOURCE LOADING
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, true, true, __LINE__ ) );
- application.GetPlatform().ClearReadyResources();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
END_TEST;
}
-#endif
-int UtcDaliRenderTaskOnceNoSync07(void)
+int UtcDaliRenderTaskMoveConstrctor(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once\n"
- "Render once, Second call to SetRefreshRate(ONCE) triggers only one more finished signal\n"
- "PRE: Everything ready\n"
- "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
+ Vector4 testColor(1.0f, 2.0f, 3.0f, 4.0f);
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(task);
+ DALI_TEST_EQUALS(2, task.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(task.GetClearColor() != testColor);
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ task.SetClearColor(testColor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- application.Render();
- application.GetPlatform().ClearReadyResources();
+ // Wait a frame.
+ Wait(application);
- Stage::GetCurrent().Add(secondRootActor);
+ DALI_TEST_EQUALS(task.GetClearColor(), testColor, TEST_LOCATION);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
- application.SendNotification();
-
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
-
- // CHANGE TO RENDER ONCE,
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ RenderTask move = std::move(task);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetClearColor(), testColor, TEST_LOCATION);
+ DALI_TEST_CHECK(!task);
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
END_TEST;
}
-int UtcDaliRenderTaskOnceNoSync08(void)
+int UtcDaliRenderTaskMoveAssignment(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once\n"
- "Render once, Call to SetRefreshRate(ONCE) in Finished signal callback triggers\n"
- "another render & another finished signal\n"
- "PRE: Everything ready\n"
- "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
+ Vector4 testColor(1.0f, 2.0f, 3.0f, 4.0f);
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(task);
+ DALI_TEST_EQUALS(2, task.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(task.GetClearColor() != testColor);
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
-
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ task.SetClearColor(testColor);
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- application.Render();
- application.GetPlatform().ClearReadyResources();
-
- Stage::GetCurrent().Add(secondRootActor);
-
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
-
- ConnectionTracker connectionTracker;
- RenderTaskFinishedRenderAgain renderTaskFinishedRenderAgain( finished );
- newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinishedRenderAgain );
-
- application.SendNotification();
-
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ // Wait a frame.
+ Wait(application);
- // CHANGE TO RENDER ONCE,
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_EQUALS(task.GetClearColor(), testColor, TEST_LOCATION);
- // Expect SetRefreshRate to have been called again
- // Prevent next finished signal calling refresh once again
- RenderTaskFinished renderTaskFinished( finished );
- connectionTracker.DisconnectAll();
- newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinished );
+ RenderTask move;
+ move = std::move(task);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetClearColor(), testColor, TEST_LOCATION);
+ DALI_TEST_CHECK(!task);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
END_TEST;
}
-
-int UtcDaliRenderTaskOnceNoSync09(void)
+int UtcDaliRenderTaskSetCullModeNegative(void)
{
- TestApplication application;
-
- tet_infoline("Testing RenderTask Render Once\n"
- "SetRefreshRate(ONCE) again before first finished signal has been sent.\n"
- "PRE: resources ready\n"
- "POST: Only 1 finished signal sent.");
-
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
-
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
-
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
- application.Render();
- application.GetPlatform().ClearReadyResources();
-
- Stage::GetCurrent().Add(secondRootActor);
-
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
- application.SendNotification();
-
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
-
- // CHANGE TO RENDER ONCE,
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
-
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetCullMode(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
END_TEST;
}
-int UtcDaliRenderTaskOnceNoSync10(void)
+int UtcDaliRenderTaskSetViewportNegative(void)
{
- TestApplication application;
-
- tet_infoline("Testing RenderTask Render Once\n"
- "SetRefreshRate(ONCE), resource load failed, completes render task.\n"
- "PRE: resources not ready\n"
- "POST: Only 1 finished signal sent.");
-
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
-
- Actor rootActor = Actor::New();
- Stage::GetCurrent().Add( rootActor );
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Rect<int> arg1;
+ instance.SetViewport(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Stage::GetCurrent().Add(secondRootActor);
+int UtcDaliRenderTaskSetExclusiveNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetExclusive(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
- application.SendNotification();
+int UtcDaliRenderTaskSetClearColorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Vector4 arg1;
+ instance.SetClearColor(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+int UtcDaliRenderTaskFinishedSignalNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.FinishedSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- // CHANGE TO RENDER ONCE,
- newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
+int UtcDaliRenderTaskSetCameraActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::CameraActor arg1;
+ instance.SetCameraActor(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- FailImageLoad(application, imageRequestId); // Need to run Update again for this to complete
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) ); // nothing to draw
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+int UtcDaliRenderTaskSetFrameBufferNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::FrameBuffer arg1;
+ instance.SetFrameBuffer(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+int UtcDaliRenderTaskSetRefreshRateNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ unsigned int arg1(0u);
+ instance.SetRefreshRate(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
END_TEST;
}
+int UtcDaliRenderTaskSetSourceActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Actor arg1;
+ instance.SetSourceActor(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+int UtcDaliRenderTaskSetClearEnabledNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetClearEnabled(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
-int UtcDaliRenderTaskOnceChain01(void)
+int UtcDaliRenderTaskSetInputEnabledNegative(void)
{
- TestApplication application;
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetInputEnabled(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- tet_infoline("Testing RenderTask Render Once Chained render tasks\n"
- "SetRefreshRate(ONCE), resource load completes, both render tasks render.\n"
- "PRE: resources not ready\n"
- "POST: 2 finished signals sent.");
+int UtcDaliRenderTaskSetViewportSizeNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Vector2 arg1;
+ instance.SetViewportSize(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
+int UtcDaliRenderTaskSetViewportPositionNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Vector2 arg1;
+ instance.SetViewportPosition(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- Actor defaultRootActor = Actor::New(); // Root for default RT
- Stage::GetCurrent().Add( defaultRootActor );
+int UtcDaliRenderTaskSetScreenToFrameBufferFunctionNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ RenderTask::ScreenToFrameBufferFunction arg1(nullptr);
+ instance.SetScreenToFrameBufferFunction(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- CameraActor offscreenCameraActor = CameraActor::New();
- Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor firstRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
- Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
- Integration::ResourceId imageRequestId = imageRequest->GetId();
- Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- Stage::GetCurrent().Add(firstRootActor);
+int UtcDaliRenderTaskSetScreenToFrameBufferMappingActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Actor arg1;
+ instance.SetScreenToFrameBufferMappingActor(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- // first render task
- RenderTask firstTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, firstRootActor, RenderTask::REFRESH_ONCE, false);
- bool firstFinished = false;
- RenderTaskFinished renderTask1Finished( firstFinished );
- firstTask.FinishedSignal().Connect( &application, renderTask1Finished );
+int UtcDaliRenderTaskGetCullModeNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetCullMode();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- // Second render task
- FrameBufferImage fbo = firstTask.GetTargetFrameBuffer();
- ImageActor secondRootActor = ImageActor::New( fbo );
- Stage::GetCurrent().Add(secondRootActor);
- RenderTask secondTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
- bool secondFinished = false;
- RenderTaskFinished renderTask2Finished( secondFinished );
- secondTask.FinishedSignal().Connect( &application, renderTask2Finished );
+int UtcDaliRenderTaskGetViewportNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetViewport();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- application.SendNotification();
+int UtcDaliRenderTaskIsExclusiveNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.IsExclusive();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- // START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, firstFinished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( firstFinished == false );
- DALI_TEST_CHECK( secondFinished == false );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, firstFinished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( firstFinished == false );
- DALI_TEST_CHECK( secondFinished == false );
+int UtcDaliRenderTaskGetClearColorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetClearColor();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- CompleteImageLoad(application, imageRequestId, imageType);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, firstFinished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( firstFinished == false );
- DALI_TEST_CHECK( secondFinished == false );
+int UtcDaliRenderTaskGetCameraActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetCameraActor();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, firstFinished, true, true, __LINE__ ) );
- DALI_TEST_CHECK( firstFinished == true );
- DALI_TEST_CHECK( secondFinished == false );
+int UtcDaliRenderTaskGetFrameBufferNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetFrameBuffer();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, secondFinished, true, false, __LINE__ ) );
- DALI_TEST_CHECK( secondFinished == true );
+int UtcDaliRenderTaskGetRefreshRateNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetRefreshRate();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+int UtcDaliRenderTaskGetSourceActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetSourceActor();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
END_TEST;
}
-int UtcDaliRenderTaskProperties(void)
+int UtcDaliRenderTaskGetClearEnabledNegative(void)
{
- TestApplication application;
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetClearEnabled();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- RenderTask task = Stage::GetCurrent().GetRenderTaskList().CreateTask();
+int UtcDaliRenderTaskGetInputEnabledNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetInputEnabled();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- Property::IndexContainer indices;
- task.GetPropertyIndices( indices );
- DALI_TEST_CHECK( indices.Size() );
- DALI_TEST_EQUALS( indices.Size(), task.GetPropertyCount(), TEST_LOCATION );
+int UtcDaliRenderTaskViewportToLocalNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Actor arg1(Actor::New());
+ float arg2(0.0f);
+ float arg3(0.0f);
+ float arg4(0.0f);
+ float arg5(0.0f);
+ instance.ViewportToLocal(arg1, arg2, arg3, arg4, arg5);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
END_TEST;
}
-int UtcDaliRenderTaskSetScreenToFrameBufferMappingActor(void)
+int UtcDaliRenderTaskWorldToViewportNegative(void)
{
- TestApplication application;
- tet_infoline("Testing RenderTask::SetScreenToFrameBufferMappingActor ");
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Vector3 arg1;
+ float arg2(0.0f);
+ float arg3(0.0f);
+ instance.WorldToViewport(arg1, arg2, arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- Stage stage = Stage::GetCurrent();
- Size stageSize = stage.GetSize();
- Actor mappingActor = Actor::New();
- Vector2 scale( 0.6f, 0.75f);
- Vector2 offset( stageSize.x*0.1f, stageSize.y*0.15f);
- mappingActor.SetSize( stageSize * scale );
- mappingActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
- mappingActor.SetPosition( offset.x, offset.y );
- stage.Add( mappingActor );
+int UtcDaliRenderTaskGetCurrentViewportSizeNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetCurrentViewportSize();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- Actor offscreenActor = Actor::New();
- offscreenActor.SetSize( stageSize );
- offscreenActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
- stage.Add( offscreenActor );
+int UtcDaliRenderTaskGetCurrentViewportPositionNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetCurrentViewportPosition();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- RenderTaskList taskList = stage.GetRenderTaskList();
- RenderTask renderTask = taskList.CreateTask();
- FrameBufferImage frameBufferImage = FrameBufferImage::New(stageSize.width*scale.x, stageSize.height*scale.y, Pixel::A8, Image::NEVER);
- renderTask.SetSourceActor( offscreenActor );
- renderTask.SetExclusive( true );
- renderTask.SetInputEnabled( true );
- renderTask.SetTargetFrameBuffer( frameBufferImage );
- renderTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
- renderTask.SetScreenToFrameBufferMappingActor( mappingActor );
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
-
- // Render and notify
- application.SendNotification();
- application.Render();
- application.Render();
- application.SendNotification();
+int UtcDaliRenderTaskGetScreenToFrameBufferFunctionNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetScreenToFrameBufferFunction();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
- Vector2 screenCoordinates( stageSize.x * 0.05f, stageSize.y * 0.05f );
- Dali::HitTestAlgorithm::Results results;
- DALI_TEST_CHECK( !results.actor );
- DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
- // miss expected, results not changed
- DALI_TEST_CHECK( false == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
- DALI_TEST_CHECK( !results.actor );
- DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
-
- screenCoordinates.x = stageSize.x * 0.265f;
- screenCoordinates.y = stageSize.y * 0.33f;
- results.actor = Actor();
- results.actorCoordinates = Vector2::ZERO;
- // hit expected, results changed
- DALI_TEST_CHECK( true == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
- DALI_TEST_CHECK( results.actor == offscreenActor );
- DALI_TEST_EQUALS( (screenCoordinates-offset)/scale , results.actorCoordinates, 0.1f, TEST_LOCATION );
-
- screenCoordinates.x = stageSize.x * 0.435f;
- screenCoordinates.y = stageSize.y * 0.52f;
- // hit expected, results changed
- DALI_TEST_CHECK( true == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
- DALI_TEST_CHECK( results.actor == offscreenActor );
- const Vector2 expectedCoordinates = (screenCoordinates-offset)/scale;
- DALI_TEST_EQUALS( expectedCoordinates , results.actorCoordinates, 0.1f, TEST_LOCATION );
-
- screenCoordinates.x = stageSize.x * 0.65f;
- screenCoordinates.y = stageSize.y * 0.95f;
- // miss expected, results not changed
- DALI_TEST_CHECK( false == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
- DALI_TEST_CHECK( results.actor == offscreenActor );
- DALI_TEST_EQUALS( expectedCoordinates , results.actorCoordinates, 0.1f, TEST_LOCATION );
+int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetScreenToFrameBufferMappingActor();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
END_TEST;
}
-int UtcDaliRenderTaskFinishInvisibleSourceActor(void)
+int UtcDaliRenderTaskClippingMode01(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask::FinishInvisibleSourceActor()");
-
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ tet_infoline("Testing clipping mode: CLIP_TO_BOUNDING_BOX.\n");
- CameraActor offscreenCameraActor = CameraActor::New();
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
- Stage::GetCurrent().Add( offscreenCameraActor );
-
- BufferImage image = BufferImage::New( 10, 10 );
- ImageActor rootActor = ImageActor::New( image );
- rootActor.SetSize( 10, 10 );
- rootActor.SetVisible(false);
- Stage::GetCurrent().Add( rootActor );
-
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
- FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
+ enabledDisableTrace.Enable(true);
+ scissorTrace.Enable(true);
- // Flush all outstanding messages
- application.SendNotification();
- application.Render();
+ // SETUP AN OFFSCREEN RENDER TASK
+ Actor rootActor = Actor::New();
+ application.GetScene().Add(rootActor);
- RenderTask newTask = taskList.CreateTask();
- newTask.SetCameraActor( offscreenCameraActor );
- newTask.SetSourceActor( rootActor );
- newTask.SetInputEnabled( false );
- newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
- newTask.SetClearEnabled( true );
- newTask.SetExclusive( true );
- newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
- newTask.SetTargetFrameBuffer( frameBufferImage );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ offscreenCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ offscreenCameraActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ application.GetScene().Add(offscreenCameraActor);
- // Framebuffer doesn't actually get created until Connected, i.e. by previous line
+ Shader shader = CreateShader();
+ Texture image = CreateTexture();
+ TextureSet textureSet = CreateTextureSet(image);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ Geometry geometry = CreateQuadGeometry();
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
- // Flush the queue and render.
- application.SendNotification();
+ Vector2 position(100.0f, 100.0f);
+ Vector2 size(200.0f, 200.0f);
+ Actor secondRootActor = Actor::New();
+ secondRootActor.AddRenderer(renderer);
+ secondRootActor.SetProperty(Actor::Property::POSITION, position);
+ secondRootActor.SetProperty(Actor::Property::SIZE, size);
+ secondRootActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ secondRootActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ secondRootActor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
+ application.GetScene().Add(secondRootActor);
- // 1 render to process render task, then wait for sync before finished msg is sent
- // from update to the event thread.
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true, TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
- application.Render();
application.SendNotification();
- DALI_TEST_CHECK( !finished );
-
- Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
-
application.Render();
- DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
- application.SendNotification();
- DALI_TEST_CHECK( !finished );
- application.Render();
- DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
- application.SendNotification();
- DALI_TEST_CHECK( ! finished );
+ std::ostringstream scissor;
+ scissor << std::hex << GL_SCISSOR_TEST;
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
- sync.SetObjectSynced( lastSyncObj, true );
-
- application.Render();
- application.SendNotification();
- DALI_TEST_CHECK( !finished );
-
- application.Render();
- application.SendNotification();
- DALI_TEST_CHECK( finished );
- finished = false;
-
- application.Render(); // Double check no more finished signal
- application.SendNotification();
- DALI_TEST_CHECK( ! finished );
+ // Check the scissor was set, and the coordinates are correct.
+ Vector4 expectResults(position.x, TestApplication::DEFAULT_SURFACE_HEIGHT - size.height - position.y, size.width, size.height); // (100, 500, 200, 200)
+ std::stringstream compareParametersString;
+ compareParametersString << expectResults.x << ", " << expectResults.y << ", " << expectResults.z << ", " << expectResults.w;
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", compareParametersString.str())); // Compare with the expected result
END_TEST;
}
-int UtcDaliRenderTaskFinishMissingImage(void)
+int UtcDaliRenderTaskClippingMode02(void)
{
TestApplication application;
- // Previously we had bugs where not having a resource ID would cause render-tasks to wait forever
- tet_infoline("Testing RenderTask::SignalFinished() when an ImageActor has no Image set");
-
- Stage stage = Stage::GetCurrent();
-
- BufferImage image = BufferImage::New( 10, 10 );
- ImageActor rootActor = ImageActor::New( image );
- rootActor.SetSize( 10, 10 );
- stage.Add( rootActor );
-
- ImageActor actorWithMissingImage = ImageActor::New( Image() );
- actorWithMissingImage.SetSize( 10, 10 );
- stage.Add( actorWithMissingImage );
-
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask newTask = taskList.CreateTask();
- newTask.SetInputEnabled( false );
- newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
- newTask.SetClearEnabled( true );
- newTask.SetExclusive( true );
- newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
-
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
-
- // 1 render to process render task, then 1 before finished msg is sent from update to the event thread.
- application.SendNotification();
- application.Render();
- application.Render();
-
- application.SendNotification();
- DALI_TEST_CHECK( finished );
-
- END_TEST;
-}
-
-int UtcDaliRenderTaskWorldToViewport(void)
-{
- TestApplication application( static_cast<size_t>(400), static_cast<size_t>(400) ); // square surface
-
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
-
- Actor actor = Actor::New();
- actor.SetSize(100.0f, 100.0f);
- actor.SetPosition( Vector3(0.0, 0.0, 0.0) );
-
- actor.SetParentOrigin( Vector3(0.5, 0.5, 0.5) );
- actor.SetAnchorPoint( Vector3(0.5, 0.5, 0.5) );
+ tet_infoline("Testing clipping mode with the inverted camera: CLIP_TO_BOUNDING_BOX.\n");
- Stage::GetCurrent().Add(actor);
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
- application.SendNotification();
- application.Render();
- application.SendNotification();
+ enabledDisableTrace.Enable(true);
+ scissorTrace.Enable(true);
- RenderTask task = taskList.GetTask( 0u );
-
- CameraActor camera = task.GetCameraActor();
+ // SETUP AN OFFSCREEN RENDER TASK
+ Actor rootActor = Actor::New();
+ application.GetScene().Add(rootActor);
- Vector2 screenSize = task.GetCurrentViewportSize();
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ offscreenCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ offscreenCameraActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ offscreenCameraActor.SetInvertYAxis(true);
+ application.GetScene().Add(offscreenCameraActor);
- float screenX = 0.0;
- float screenY = 0.0;
+ Shader shader = CreateShader();
+ Texture image = CreateTexture();
+ TextureSet textureSet = CreateTextureSet(image);
- bool ok = task.WorldToViewport(actor.GetCurrentWorldPosition(), screenX, screenY);
- DALI_TEST_CHECK(ok == true);
+ Geometry geometry = CreateQuadGeometry();
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
- DALI_TEST_EQUALS(screenX, screenSize.x/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
- DALI_TEST_EQUALS(screenY, screenSize.y/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ Vector2 position(100.0f, 100.0f);
+ Vector2 size(200.0f, 200.0f);
+ Actor secondRootActor = Actor::New();
+ secondRootActor.AddRenderer(renderer);
+ secondRootActor.SetProperty(Actor::Property::POSITION, position);
+ secondRootActor.SetProperty(Actor::Property::SIZE, size);
+ secondRootActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ secondRootActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ secondRootActor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
+ application.GetScene().Add(secondRootActor);
- Actor actor2 = Actor::New();
- float actor2Size = 100.f;
- actor2.SetSize( actor2Size, actor2Size );
- actor2.SetPosition( Vector3(0.0, 0.0, 0.0) );
- actor2.SetParentOrigin( Vector3(0.5, 0.5, 0.0) );
- actor2.SetAnchorPoint( Vector3(0.5, 0.5, 0.0) );
- Stage::GetCurrent().Add( actor2 );
- actor2.Add(actor);
- actor.SetParentOrigin( Vector3(0,0,0) );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true, TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
application.SendNotification();
application.Render();
- application.SendNotification();
- ok = task.WorldToViewport(actor.GetCurrentWorldPosition(), screenX, screenY);
- DALI_TEST_CHECK(ok == true);
+ std::ostringstream scissor;
+ scissor << std::hex << GL_SCISSOR_TEST;
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
- DALI_TEST_EQUALS(screenX, screenSize.x/2 - actor2Size/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
- DALI_TEST_EQUALS(screenY, screenSize.y/2 - actor2Size/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ // Check the scissor was set, and the coordinates are correct.
+ Vector4 expectResults(position.x, position.y, size.width, size.height); // (100, 100, 200, 200)
+ std::stringstream compareParametersString;
+ compareParametersString << expectResults.x << ", " << expectResults.y << ", " << expectResults.z << ", " << expectResults.w;
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", compareParametersString.str())); // Compare with the expected result
END_TEST;
}
-
-int UtcDaliRenderTaskViewportToLocal(void)
+int UtcDaliRenderTaskUploadOnly(void)
{
TestApplication application;
- Actor actor = Actor::New();
- actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
- actor.SetSize(100.0f, 100.0f);
- actor.SetPosition(10.0f, 10.0f);
- Stage::GetCurrent().Add(actor);
- RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ tet_infoline("Testing RenderTask Render Once GlSync, using loaded image");
- // flush the queue and render once
- application.SendNotification();
- application.Render();
- application.SendNotification();
- application.Render();
+ // SETUP AN OFFSCREEN RENDER TASK
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ auto& sync = application.GetGraphicsSyncImpl();
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ drawTrace.Enable(true);
- float localX;
- float localY;
+ Actor rootActor = Actor::New();
+ application.GetScene().Add(rootActor);
- float rtLocalX;
- float rtLocalY;
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
- float screenX = 50.0f;
- float screenY = 50.0f;
+ application.GetScene().Add(secondRootActor);
- DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, screenX, screenY) );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
+ application.SendNotification();
- DALI_TEST_CHECK( task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
- DALI_TEST_EQUALS(localX, rtLocalX, 0.01f, TEST_LOCATION);
- DALI_TEST_EQUALS(localY, rtLocalY, 0.01f, TEST_LOCATION);
+ Integration::GraphicsSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
+ DALI_TEST_CHECK(lastSyncObj != NULL);
+ sync.SetObjectSynced(lastSyncObj, true);
- END_TEST;
+ application.SendNotification();
+ application.Render(16, nullptr, true);
-}
+ DALI_TEST_CHECK(!finished);
+
+ application.Render(16, nullptr, true);
+ application.SendNotification();
+
+ DALI_TEST_CHECK(!finished);
+ END_TEST;
+}
\ No newline at end of file