/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
namespace
{
-bool gTouchCallBackCalled = false;
-bool gTouchCallBackCalled2 = false;
-bool gTouchCallBackCalled3 = false;
+bool gTouchCallBackCalled = false;
+bool gTouchCallBackCalled2 = false;
+bool gTouchCallBackCalled3 = false;
+bool gHitTestTouchCallBackCalled = false;
bool gHoverCallBackCalled = false;
END_TEST;
}
+static bool TestHitTestTouchCallback(Actor, const TouchEvent&)
+{
+ gHitTestTouchCallBackCalled = true;
+ return false;
+ END_TEST;
+}
+
static void ResetTouchCallbacks()
{
gTouchCallBackCalled = false;
actor.SetProperty(Actor::Property::POSITION, Vector3(2.0f, 2.0f, 16.0f));
actor.SetProperty(Actor::Property::SIZE, Vector3{1.0f, 1.0f, 1.0f});
+ application.GetScene().Add(actor);
+
application.SendNotification();
application.Render();
- auto expectedExtent = Rect<>{-0.5f, -0.5f, 1.0f, 1.0f};
+ auto expectedExtent = Rect<>{1.5f, 1.5f, 1.0f, 1.0f};
auto actualExtent = DevelActor::CalculateScreenExtents(actor);
DALI_TEST_EQUALS(expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
DALI_TEST_EQUALS(expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
END_TEST;
}
+int UtcDaliActorCalculateScreenExtentsInCustomCameraAndLayer3D(void)
+{
+ TestApplication application;
+ Integration::Scene scene = application.GetScene();
+
+ // Make 3D Layer
+ Layer layer = Layer::New();
+ layer.SetProperty(Layer::Property::BEHAVIOR, Layer::Behavior::LAYER_3D);
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ layer.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+
+ scene.Add(layer);
+
+ // Build custom camera with top-view
+ CameraActor cameraActor = scene.GetRenderTaskList().GetTask(0).GetCameraActor();
+ {
+ // Default camera position at +z and looking -z axis. (orientation is [ Axis: [0, 1, 0], Angle: 180 degrees ])
+ Vector3 cameraPos = cameraActor.GetProperty<Vector3>(Actor::Property::POSITION);
+ Quaternion cameraOrient = cameraActor.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+
+ {
+ std::ostringstream oss;
+ oss << cameraPos << "\n";
+ oss << cameraOrient << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+
+ cameraActor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, -cameraPos.z, 0.0f));
+ cameraActor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(90.0f), Vector3::XAXIS) * cameraOrient);
+
+ // Now, upside : -Z, leftside : -X, foward : +Y
+
+ cameraPos = cameraActor.GetProperty<Vector3>(Actor::Property::POSITION);
+ cameraOrient = cameraActor.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+ {
+ std::ostringstream oss;
+ oss << cameraPos << "\n";
+ oss << cameraOrient << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+ }
+
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::POSITION, Vector3(2.0f, 0.0f, 16.0f));
+ actor.SetProperty(Actor::Property::SIZE, Vector3{1.0f, 0.0f, 3.0f});
+
+ layer.Add(actor);
+
+ application.SendNotification();
+ application.Render();
+
+ Vector2 sceneSize = scene.GetSize();
+
+ auto expectedExtent = Rect<>{sceneSize.x * 0.5f + 1.5f, sceneSize.y * 0.5f + 14.5f, 1.0f, 3.0f};
+ auto actualExtent = DevelActor::CalculateScreenExtents(actor);
+ {
+ std::ostringstream oss;
+ oss << expectedExtent << "\n";
+ oss << actualExtent << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+
+ DALI_TEST_EQUALS(expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.width, actualExtent.width, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.height, actualExtent.height, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliActorCalculateScreenInCustomCameraAndOffscreenLayer3D(void)
+{
+ // TODO : Need to make it works well
+ TestApplication application;
+ Integration::Scene scene = application.GetScene();
+ Vector2 sceneSize = scene.GetSize();
+
+ // Make 3D Layer
+ Layer layer = Layer::New();
+ layer.SetProperty(Layer::Property::BEHAVIOR, Layer::Behavior::LAYER_3D);
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ layer.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ layer.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ layer.SetProperty(Actor::Property::SIZE, sceneSize);
+
+ scene.Add(layer);
+
+ // Build custom camera with top-view
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+
+ offscreenCameraActor.SetPerspectiveProjection(sceneSize);
+ offscreenCameraActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ offscreenCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+
+ scene.Add(offscreenCameraActor);
+ {
+ // Default camera position at +z and looking -z axis. (orientation is [ Axis: [0, 1, 0], Angle: 180 degrees ])
+ Vector3 cameraPos = offscreenCameraActor.GetProperty<Vector3>(Actor::Property::POSITION);
+ Quaternion cameraOrient = offscreenCameraActor.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+
+ {
+ std::ostringstream oss;
+ oss << cameraPos << "\n";
+ oss << cameraOrient << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+
+ offscreenCameraActor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, -cameraPos.z, 0.0f));
+ offscreenCameraActor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(90.0f), Vector3::XAXIS) * cameraOrient);
+
+ // Now, upside : -Z, leftside : -X, foward : +Y
+
+ cameraPos = offscreenCameraActor.GetProperty<Vector3>(Actor::Property::POSITION);
+ cameraOrient = offscreenCameraActor.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+ {
+ std::ostringstream oss;
+ oss << cameraPos << "\n";
+ oss << cameraOrient << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+ }
+ Vector3 sourcePosition{2.0f, 0.0f, 16.0f};
+ Vector3 sourceSize{1.0f, 0.0f, 3.0f};
+
+ Actor sourceActor = Actor::New();
+ sourceActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ sourceActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ sourceActor.SetProperty(Actor::Property::POSITION, sourcePosition);
+ sourceActor.SetProperty(Actor::Property::SIZE, sourceSize);
+
+ layer.Add(sourceActor);
+
+ // Create framebuffer
+ unsigned int width(64);
+ unsigned int height(64);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::DEPTH_STENCIL);
+ frameBuffer.AttachColorTexture(texture);
+
+ Actor rootActor = Actor::New();
+ rootActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ rootActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ rootActor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ rootActor.SetProperty(Actor::Property::SIZE, sceneSize);
+ scene.Add(rootActor);
+
+ RenderTaskList taskList = scene.GetRenderTaskList();
+ RenderTask newTask = taskList.CreateTask();
+ newTask.SetCameraActor(offscreenCameraActor);
+ newTask.SetSourceActor(layer);
+ newTask.SetInputEnabled(false);
+ newTask.SetClearColor(Vector4(0.f, 0.f, 0.f, 0.f));
+ newTask.SetClearEnabled(true);
+ newTask.SetExclusive(true);
+ newTask.SetFrameBuffer(frameBuffer);
+ newTask.SetScreenToFrameBufferMappingActor(rootActor);
+
+ application.SendNotification();
+ application.Render(16u);
+
+ auto expectedExtent = Rect<>{sceneSize.x * 0.5f + sourcePosition.x - sourceSize.x * 0.5f,
+ sceneSize.y * 0.5f + sourcePosition.z - sourceSize.z * 0.5f,
+ sourceSize.x,
+ sourceSize.z};
+ auto actualExtent = DevelActor::CalculateScreenExtents(sourceActor);
+ {
+ std::ostringstream oss;
+ oss << expectedExtent << "\n";
+ oss << actualExtent << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+
+ auto expectedScreen = Vector2{sceneSize.x * 0.5f + sourcePosition.x, sceneSize.y * 0.5f + sourcePosition.z};
+ auto actualScreen = sourceActor.GetProperty<Vector2>(Actor::Property::SCREEN_POSITION);
+ {
+ std::ostringstream oss;
+ oss << expectedScreen << "\n";
+ oss << actualScreen << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+
+ DALI_TEST_EQUALS(expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.width, actualExtent.width, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.height, actualExtent.height, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+
+ DALI_TEST_EQUALS(expectedScreen.x, actualScreen.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedScreen.y, actualScreen.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+
+ // Change rootActor's size and position
+
+ Vector3 rootPosition{100.0f, 200.0f, 0.0f};
+ Vector3 rootSize{200.0f, 100.0f, 0.0f};
+
+ rootActor.SetProperty(Actor::Property::POSITION, rootPosition);
+ rootActor.SetProperty(Actor::Property::SIZE, rootSize);
+
+ application.SendNotification();
+ application.Render(16u);
+
+ expectedExtent = Rect<>{sceneSize.x * 0.5f + rootPosition.x + (sourcePosition.x - sourceSize.x * 0.5f) * rootSize.x / sceneSize.x,
+ sceneSize.y * 0.5f + rootPosition.y + (sourcePosition.z - sourceSize.z * 0.5f) * rootSize.y / sceneSize.y,
+ sourceSize.x * rootSize.x / sceneSize.x,
+ sourceSize.z * rootSize.y / sceneSize.y};
+ actualExtent = DevelActor::CalculateScreenExtents(sourceActor);
+ {
+ std::ostringstream oss;
+ oss << expectedExtent << "\n";
+ oss << actualExtent << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+
+ expectedScreen = Vector2{sceneSize.x * 0.5f + rootPosition.x + sourcePosition.x * rootSize.x / sceneSize.x, sceneSize.y * 0.5f + rootPosition.y + sourcePosition.z * rootSize.y / sceneSize.y};
+ actualScreen = sourceActor.GetProperty<Vector2>(Actor::Property::SCREEN_POSITION);
+ {
+ std::ostringstream oss;
+ oss << expectedScreen << "\n";
+ oss << actualScreen << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+
+ DALI_TEST_EQUALS(expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.width, actualExtent.width, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.height, actualExtent.height, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+
+ DALI_TEST_EQUALS(expectedScreen.x, actualScreen.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedScreen.y, actualScreen.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+
+ END_TEST;
+}
+
// SetPosition(float x, float y)
int UtcDaliActorSetPosition01(void)
{
END_TEST;
}
+int UtcDaliActorSetUserInteractionEnabled(void)
+{
+ TestApplication application;
+ Actor actor = Actor::New();
+
+ bool enabled = !actor.GetProperty<bool>(DevelActor::Property::USER_INTERACTION_ENABLED);
+
+ actor.SetProperty(DevelActor::Property::USER_INTERACTION_ENABLED, enabled);
+
+ DALI_TEST_CHECK(enabled == actor.GetProperty<bool>(DevelActor::Property::USER_INTERACTION_ENABLED));
+ END_TEST;
+}
+
+int UtcDaliActorIsUserInteractionEnabled(void)
+{
+ TestApplication application;
+ Actor actor = Actor::New();
+ actor.SetProperty(DevelActor::Property::USER_INTERACTION_ENABLED, true);
+
+ DALI_TEST_CHECK(true == actor.GetProperty<bool>(DevelActor::Property::USER_INTERACTION_ENABLED));
+ END_TEST;
+}
+
int UtcDaliActorRemoveConstraints(void)
{
tet_infoline(" UtcDaliActorRemoveConstraints");
// Check stencil functions are not called.
DALI_TEST_CHECK(!stencilTrace.FindMethod("StencilFunc"));
- // TODO: Temporarily commented out the line below when caching is disabled. Will need to add it back.
- // DALI_TEST_CHECK(!stencilTrace.FindMethod("StencilMask"));
DALI_TEST_CHECK(!stencilTrace.FindMethod("StencilOp"));
// Check that scissor clipping is overriden by the renderer properties.
END_TEST;
}
+int UtcDaliActorGetScreenPositionResizeScene(void)
+{
+ tet_infoline("UtcDaliActorGetScreenPositionResizeScene Check screen position after resizing the scene size");
+
+ TestApplication application;
+ Integration::Scene scene = application.GetScene();
+
+ Actor actorA = Actor::New();
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actorA.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+
+ scene.Add(actorA);
+
+ application.SendNotification();
+ application.Render();
+
+ Vector2 sceneSize = scene.GetSize();
+ Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
+
+ DALI_TEST_EQUALS(actorScreenPosition, sceneSize / 2, TEST_LOCATION);
+
+ // Resize the scene
+ Vector2 newSize(1000.0f, 2000.0f);
+ DALI_TEST_CHECK(scene.GetSize() != newSize);
+
+ scene.SurfaceResized(newSize.width, newSize.height);
+
+ actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
+
+ // The screen position should not be updated yet
+ DALI_TEST_EQUALS(actorScreenPosition, sceneSize / 2, TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render();
+
+ actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
+
+ // The screen position should be updated
+ sceneSize = scene.GetSize();
+ DALI_TEST_EQUALS(actorScreenPosition, sceneSize / 2, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliActorGetScreenPositionInCustomCameraAndLayer3D(void)
+{
+ tet_infoline("UtcDaliActorGetScreenPositionInCustomCameraAndLayer3D Check screen position under LAYER_3D and custom camera");
+
+ TestApplication application;
+ Integration::Scene scene = application.GetScene();
+
+ // Make 3D Layer
+ Layer layer = scene.GetRootLayer();
+ layer.SetProperty(Layer::Property::BEHAVIOR, Layer::Behavior::LAYER_3D);
+
+ // Build custom camera with top-view
+ CameraActor cameraActor = scene.GetRenderTaskList().GetTask(0).GetCameraActor();
+ {
+ // Default camera position at +z and looking -z axis. (orientation is [ Axis: [0, 1, 0], Angle: 180 degrees ])
+ Vector3 cameraPos = cameraActor.GetProperty<Vector3>(Actor::Property::POSITION);
+ Quaternion cameraOrient = cameraActor.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+
+ {
+ std::ostringstream oss;
+ oss << cameraPos << "\n";
+ oss << cameraOrient << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+
+ cameraActor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, -cameraPos.z, 0.0f));
+ cameraActor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(90.0f), Vector3::XAXIS) * cameraOrient);
+
+ // Now, upside : -Z, leftside : -X, foward : +Y
+
+ cameraPos = cameraActor.GetProperty<Vector3>(Actor::Property::POSITION);
+ cameraOrient = cameraActor.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+ {
+ std::ostringstream oss;
+ oss << cameraPos << "\n";
+ oss << cameraOrient << "\n";
+ tet_printf("%s\n", oss.str().c_str());
+ }
+ }
+
+ Actor actorA = Actor::New();
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actorA.SetProperty(Actor::Property::SIZE, Vector3(10.0f, 10.0f, 10.0f));
+ actorA.SetProperty(Actor::Property::POSITION, Vector3(20.0f, 0.0f, 10.0f));
+
+ Actor actorB = Actor::New();
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actorB.SetProperty(Actor::Property::SIZE, Vector3(10.0f, 10.0f, 10.0f));
+ actorB.SetProperty(Actor::Property::POSITION, Vector3(-20.0f, 0.0f, -10.0f));
+
+ scene.Add(actorA);
+ scene.Add(actorB);
+
+ application.SendNotification();
+ application.Render();
+
+ Vector2 sceneSize = scene.GetSize();
+ Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
+
+ DALI_TEST_EQUALS(actorScreenPosition, sceneSize / 2 + Vector2(20.0f, 10.0f), TEST_LOCATION);
+
+ actorScreenPosition = actorB.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
+
+ DALI_TEST_EQUALS(actorScreenPosition, sceneSize / 2 - Vector2(20.0f, 10.0f), TEST_LOCATION);
+
+ END_TEST;
+}
+
int utcDaliActorPositionUsesAnchorPoint(void)
{
TestApplication application;
application.GetScene().Remove(actor);
application.SendNotification();
- // Actor removed, last 3 dirty rects are reported. Adaptor would merge them together.
+ // Actor removed, last a dirty rect is reported.
damagedRects.clear();
application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
- DALI_TEST_EQUALS(damagedRects.size(), 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
clippingRect = damagedRects[0];
- clippingRect.Merge(damagedRects[1]);
- clippingRect.Merge(damagedRects[2]);
- DALI_TEST_EQUALS(clippingRect.IsEmpty(), false, TEST_LOCATION);
DALI_TEST_EQUALS(clippingRect.IsValid(), true, TEST_LOCATION);
- DALI_TEST_EQUALS<Rect<int>>(clippingRect, Rect<int>(16, 736, 64, 64), TEST_LOCATION);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, Rect<int>(32, 736, 48, 48), TEST_LOCATION);
application.RenderWithPartialUpdate(damagedRects, clippingRect);
DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+ // Change a Renderer of actor1
+ Geometry geometry = CreateQuadGeometry();
+ Shader shader = CreateShader();
+ Renderer newRenderer = Renderer::New(geometry, shader);
+ Renderer renderer = actor.GetRendererAt(0);
+
+ actor.RemoveRenderer(renderer);
+ actor.AddRenderer(newRenderer);
+
+ damagedRects.clear();
+
+ application.SendNotification();
+ application.PreRenderWithPartialUpdate(TestApplication::DEFAULT_RENDER_INTERVAL, nullptr, damagedRects);
+
+ DALI_TEST_CHECK(damagedRects.size() > 0);
+ DALI_TEST_EQUALS<Rect<int>>(Rect<int>(64, 672, 64, 64), damagedRects[0], TEST_LOCATION);
+
+ // in screen coordinates, adaptor would calculate it using previous frames information
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
END_TEST;
}
Actor actor = CreateRenderableActor();
actor.SetProperty(Actor::Property::POSITION, Vector3(64.0f, 64.0f, 0.0f));
actor.SetProperty(Actor::Property::SIZE, Vector3(32.0f, 32.0f, 0.0f));
- actor.SetProperty(DevelActor::Property::UPDATE_SIZE_HINT, Vector3(64.0f, 64.0f, 0.0f));
+ actor.SetProperty(Actor::Property::UPDATE_AREA_HINT, Vector4(0.0f, 0.0f, 64.0f, 64.0f));
actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
application.GetScene().Add(actor);
DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
- END_TEST;
-}
-
-int utcDaliActorPartialUpdateAnimation(void)
-{
- TestApplication application(
- TestApplication::DEFAULT_SURFACE_WIDTH,
- TestApplication::DEFAULT_SURFACE_HEIGHT,
- TestApplication::DEFAULT_HORIZONTAL_DPI,
- TestApplication::DEFAULT_VERTICAL_DPI,
- true,
- true);
-
- tet_infoline("Check the damaged area with partial update and animation");
-
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
- drawTrace.Enable(true);
- drawTrace.Reset();
-
- Actor actor1 = CreateRenderableActor();
- actor1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
- actor1.SetProperty(Actor::Property::SIZE, Vector3(80.0f, 80.0f, 0.0f));
- application.GetScene().Add(actor1);
-
- Actor actor2 = CreateRenderableActor();
- actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
- actor2.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
- application.GetScene().Add(actor2);
-
- std::vector<Rect<int>> damagedRects;
- Rect<int> clippingRect;
- Rect<int> expectedRect1, expectedRect2;
+ // Reset
+ actor.Unparent();
+ damagedRects.clear();
application.SendNotification();
- application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.PreRenderWithPartialUpdate(TestApplication::DEFAULT_RENDER_INTERVAL, nullptr, damagedRects);
- DALI_TEST_EQUALS(damagedRects.size(), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
- // Aligned by 16
- expectedRect1 = Rect<int>(0, 720, 96, 96); // in screen coordinates, includes 3 last frames updates
- expectedRect2 = Rect<int>(0, 784, 32, 32); // in screen coordinates, includes 3 last frames updates
- DALI_TEST_EQUALS<Rect<int>>(expectedRect1, damagedRects[0], TEST_LOCATION);
- DALI_TEST_EQUALS<Rect<int>>(expectedRect2, damagedRects[1], TEST_LOCATION);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
- clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
application.RenderWithPartialUpdate(damagedRects, clippingRect);
damagedRects.clear();
- clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
application.RenderWithPartialUpdate(damagedRects, clippingRect);
- // Make an animation
- Animation animation = Animation::New(1.0f);
- animation.AnimateTo(Property(actor2, Actor::Property::POSITION_X), 160.0f, TimePeriod(0.5f, 0.5f));
- animation.Play();
+ // Ensure the damaged rect is empty
+ DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+
+ // Chnage UPDATE_AREA_HINT
+ actor.SetProperty(Actor::Property::UPDATE_AREA_HINT, Vector4(16.0f, 16.0f, 32.0f, 32.0f));
+ application.GetScene().Add(actor);
+
+ application.SendNotification();
+ application.PreRenderWithPartialUpdate(TestApplication::DEFAULT_RENDER_INTERVAL, nullptr, damagedRects);
+
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+ clippingRect = Rect<int>(64, 704, 48, 48);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+ // Reset
+ actor.Unparent();
+
+ damagedRects.clear();
+ application.SendNotification();
+ application.PreRenderWithPartialUpdate(TestApplication::DEFAULT_RENDER_INTERVAL, nullptr, damagedRects);
+
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Ensure the damaged rect is empty
+ DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+
+ // Chnage UPDATE_AREA_HINT
+ actor.SetProperty(Actor::Property::UPDATE_AREA_HINT, Vector4(-32.0f, -16.0f, 64.0f, 64.0f));
+ application.GetScene().Add(actor);
+
+ application.SendNotification();
+ application.PreRenderWithPartialUpdate(TestApplication::DEFAULT_RENDER_INTERVAL, nullptr, damagedRects);
+
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+ clippingRect = Rect<int>(0, 720, 80, 80);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int utcDaliActorPartialUpdateAnimation(void)
+{
+ TestApplication application(
+ TestApplication::DEFAULT_SURFACE_WIDTH,
+ TestApplication::DEFAULT_SURFACE_HEIGHT,
+ TestApplication::DEFAULT_HORIZONTAL_DPI,
+ TestApplication::DEFAULT_VERTICAL_DPI,
+ true,
+ true);
+
+ tet_infoline("Check the damaged area with partial update and animation");
+
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ drawTrace.Enable(true);
+ drawTrace.Reset();
+
+ Actor actor1 = CreateRenderableActor();
+ actor1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor1.SetProperty(Actor::Property::SIZE, Vector3(80.0f, 80.0f, 0.0f));
+ application.GetScene().Add(actor1);
+
+ Actor actor2 = CreateRenderableActor();
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor2.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
+ application.GetScene().Add(actor2);
+
+ std::vector<Rect<int>> damagedRects;
+ Rect<int> clippingRect;
+ Rect<int> expectedRect1, expectedRect2;
+
+ application.SendNotification();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+
+ DALI_TEST_EQUALS(damagedRects.size(), 2, TEST_LOCATION);
+
+ // Aligned by 16
+ expectedRect1 = Rect<int>(0, 720, 96, 96); // in screen coordinates, includes 3 last frames updates
+ expectedRect2 = Rect<int>(0, 784, 32, 32); // in screen coordinates, includes 3 last frames updates
+ DALI_TEST_EQUALS<Rect<int>>(expectedRect1, damagedRects[0], TEST_LOCATION);
+ DALI_TEST_EQUALS<Rect<int>>(expectedRect2, damagedRects[1], TEST_LOCATION);
+
+ clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ damagedRects.clear();
+ clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Make an animation
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(actor2, Actor::Property::POSITION_X), 160.0f, TimePeriod(0.5f, 0.5f));
+ animation.Play();
application.SendNotification();
// Started animation
damagedRects.clear();
application.PreRenderWithPartialUpdate(500, nullptr, damagedRects);
- DALI_TEST_EQUALS(damagedRects.size(), 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(damagedRects.size(), 3, TEST_LOCATION);
// The first dirty rect is actor3's.
// We don't know the exact dirty rect of actor2
END_TEST;
}
-int UtcDaliActorCaptureAllTouchAfterStartPropertyP(void)
+int utcDaliActorPartialUpdateNotRenderableActor(void)
{
- TestApplication application;
+ TestApplication application(
+ TestApplication::DEFAULT_SURFACE_WIDTH,
+ TestApplication::DEFAULT_SURFACE_HEIGHT,
+ TestApplication::DEFAULT_HORIZONTAL_DPI,
+ TestApplication::DEFAULT_VERTICAL_DPI,
+ true,
+ true);
- Actor actor = Actor::New();
- DALI_TEST_EQUALS(actor.GetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START).Get<bool>(), false, TEST_LOCATION);
- actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, true);
- DALI_TEST_EQUALS(actor.GetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START).Get<bool>(), true, TEST_LOCATION);
- DALI_TEST_EQUALS(actor.GetPropertyType(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), Property::BOOLEAN, TEST_LOCATION);
- DALI_TEST_EQUALS(actor.IsPropertyWritable(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), true, TEST_LOCATION);
- DALI_TEST_EQUALS(actor.IsPropertyAnimatable(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), false, TEST_LOCATION);
- DALI_TEST_EQUALS(actor.IsPropertyAConstraintInput(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), false, TEST_LOCATION);
- DALI_TEST_EQUALS(actor.GetPropertyName(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), "captureAllTouchAfterStart", TEST_LOCATION);
- END_TEST;
-}
+ tet_infoline("Check the damaged rect with not renderable parent actor");
-int UtcDaliActorCaptureAllTouchAfterStartPropertyN(void)
-{
- TestApplication application;
+ const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
- Actor actor = Actor::New();
+ Actor parent = Actor::New();
+ parent[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ parent[Actor::Property::POSITION] = Vector3(16.0f, 16.0f, 0.0f);
+ parent[Actor::Property::SIZE] = Vector3(16.0f, 16.0f, 0.0f);
+ parent.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ application.GetScene().Add(parent);
- // Make sure setting invalid types does not cause a crash
- try
- {
- actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, 1.0f);
- actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector2::ONE);
- actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector3::ONE);
- actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector4::ONE);
- actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Property::Map());
- actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Property::Array());
- tet_result(TET_PASS);
- }
- catch(...)
- {
- tet_result(TET_FAIL);
- }
- END_TEST;
-}
+ Actor child = CreateRenderableActor();
+ child[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ child[Actor::Property::SIZE] = Vector3(16.0f, 16.0f, 0.0f);
+ child.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ parent.Add(child);
-int UtcDaliActorTouchAreaOffsetPropertyP(void)
-{
- TestApplication application;
+ application.SendNotification();
- Actor actor = Actor::New();
- Rect<int> touchAreaOffset = actor.GetProperty(DevelActor::Property::TOUCH_AREA_OFFSET).Get<Rect<int>>();
- DALI_TEST_EQUALS(Rect<int>(0, 0, 0, 0), touchAreaOffset, TEST_LOCATION);
- actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Rect<int>(10, 20, 30, 40));
- touchAreaOffset = actor.GetProperty(DevelActor::Property::TOUCH_AREA_OFFSET).Get<Rect<int>>();
- DALI_TEST_EQUALS(Rect<int>(10, 20, 30, 40), touchAreaOffset, TEST_LOCATION);
- END_TEST;
-}
+ std::vector<Rect<int>> damagedRects;
-int UtcDaliActorTouchAreaOffsetPropertyN(void)
-{
- TestApplication application;
+ // 1. Actor added, damaged rect is added size of actor
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
- Actor actor = Actor::New();
+ // Aligned by 16
+ Rect<int> clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
- // Make sure setting invalid types does not cause a crash
- try
- {
- actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, 1.0f);
- actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Vector2::ONE);
- actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Vector3::ONE);
- actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Vector4::ONE);
- actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Property::Map());
- actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Property::Array());
- tet_result(TET_PASS);
- }
- catch(...)
- {
- tet_result(TET_FAIL);
- }
- END_TEST;
-}
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
-int UtcDaliActorLowerBelowNegative(void)
-{
- TestApplication application;
- Dali::Actor instance;
- try
- {
- Dali::Actor arg1;
- instance.LowerBelow(arg1);
- DALI_TEST_CHECK(false); // Should not get here
- }
- catch(...)
- {
- DALI_TEST_CHECK(true); // We expect an assert
- }
- END_TEST;
-}
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
-int UtcDaliActorRaiseAboveNegative(void)
-{
- TestApplication application;
- Dali::Actor instance;
- try
- {
- Dali::Actor arg1;
- instance.RaiseAbove(arg1);
- DALI_TEST_CHECK(false); // Should not get here
- }
- catch(...)
- {
- DALI_TEST_CHECK(true); // We expect an assert
- }
- END_TEST;
-}
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Ensure the damaged rect is empty
+ DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
-int UtcDaliActorRaiseToTopNegative(void)
-{
- TestApplication application;
- Dali::Actor instance;
- try
- {
- instance.RaiseToTop();
- DALI_TEST_CHECK(false); // Should not get here
- }
- catch(...)
- {
- DALI_TEST_CHECK(true); // We expect an assert
- }
+ END_TEST;
+}
+
+int utcDaliActorPartialUpdateChangeTransparency(void)
+{
+ TestApplication application(
+ TestApplication::DEFAULT_SURFACE_WIDTH,
+ TestApplication::DEFAULT_SURFACE_HEIGHT,
+ TestApplication::DEFAULT_HORIZONTAL_DPI,
+ TestApplication::DEFAULT_VERTICAL_DPI,
+ true,
+ true);
+
+ tet_infoline("Check the damaged rect with changing transparency");
+
+ const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
+
+ Actor actor = CreateRenderableActor();
+ actor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ actor[Actor::Property::POSITION] = Vector3(16.0f, 16.0f, 0.0f);
+ actor[Actor::Property::SIZE] = Vector3(16.0f, 16.0f, 0.0f);
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ application.GetScene().Add(actor);
+
+ application.SendNotification();
+
+ std::vector<Rect<int>> damagedRects;
+
+ // Actor added, damaged rect is added size of actor
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+ // Aligned by 16
+ Rect<int> clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Make the actor transparent by changing opacity of the Renderer
+ // It changes a uniform value
+ Renderer renderer = actor.GetRendererAt(0);
+ renderer[DevelRenderer::Property::OPACITY] = 0.0f;
+
+ application.SendNotification();
+
+ // The damaged rect should be same
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_CHECK(damagedRects.size() > 0);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Ensure the damaged rect is empty
+ DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+
+ // Make the actor opaque again
+ renderer[DevelRenderer::Property::OPACITY] = 1.0f;
+
+ application.SendNotification();
+
+ // The damaged rect should not be empty
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Ensure the damaged rect is empty
+ DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+
+ // Make the actor translucent
+ renderer[DevelRenderer::Property::OPACITY] = 0.5f;
+
+ application.SendNotification();
+
+ // The damaged rect should not be empty
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Ensure the damaged rect is empty
+ DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+
+ // Change Renderer opacity - also translucent
+ renderer[DevelRenderer::Property::OPACITY] = 0.2f;
+
+ application.SendNotification();
+
+ // The damaged rect should not be empty
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Ensure the damaged rect is empty
+ DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+
+ // Make the actor culled
+ actor[Actor::Property::SIZE] = Vector3(0.0f, 0.0f, 0.0f);
+
+ application.SendNotification();
+
+ // The damaged rect should be same
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_CHECK(damagedRects.size() > 0);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Ensure the damaged rect is empty
+ DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+
+ // Make the actor not culled again
+ actor[Actor::Property::SIZE] = Vector3(16.0f, 16.0f, 16.0f);
+
+ application.SendNotification();
+
+ // The damaged rect should not be empty
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ END_TEST;
+}
+
+int utcDaliActorPartialUpdateChangeParentOpacity(void)
+{
+ TestApplication application(
+ TestApplication::DEFAULT_SURFACE_WIDTH,
+ TestApplication::DEFAULT_SURFACE_HEIGHT,
+ TestApplication::DEFAULT_HORIZONTAL_DPI,
+ TestApplication::DEFAULT_VERTICAL_DPI,
+ true,
+ true);
+
+ tet_infoline("Check the damaged rect with changing parent's opacity");
+
+ const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
+
+ Actor parent = Actor::New();
+ parent[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ parent[Actor::Property::POSITION] = Vector3(16.0f, 16.0f, 0.0f);
+ parent[Actor::Property::SIZE] = Vector3(16.0f, 16.0f, 0.0f);
+ parent.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ application.GetScene().Add(parent);
+
+ Texture texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 16u, 16u);
+ Actor child = CreateRenderableActor(texture);
+ child[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ child[Actor::Property::SIZE] = Vector3(16.0f, 16.0f, 0.0f);
+ child.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ parent.Add(child);
+
+ application.SendNotification();
+
+ std::vector<Rect<int>> damagedRects;
+
+ // Actor added, damaged rect is added size of actor
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+ // Aligned by 16
+ Rect<int> clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Ensure the damaged rect is empty
+ DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+
+ // Change the parent's opacity
+ parent[Actor::Property::OPACITY] = 0.5f;
+
+ application.SendNotification();
+
+ // The damaged rect should be same
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_CHECK(damagedRects.size() > 0);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ END_TEST;
+}
+
+int utcDaliActorPartialAddRemoveRenderer(void)
+{
+ TestApplication application(
+ TestApplication::DEFAULT_SURFACE_WIDTH,
+ TestApplication::DEFAULT_SURFACE_HEIGHT,
+ TestApplication::DEFAULT_HORIZONTAL_DPI,
+ TestApplication::DEFAULT_VERTICAL_DPI,
+ true,
+ true);
+
+ tet_infoline("Check the damaged rect with adding / removing renderer");
+
+ const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
+
+ Actor actor = CreateRenderableActor();
+ actor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ actor[Actor::Property::POSITION] = Vector3(16.0f, 16.0f, 0.0f);
+ actor[Actor::Property::SIZE] = Vector3(16.0f, 16.0f, 0.0f);
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ application.GetScene().Add(actor);
+
+ application.SendNotification();
+
+ std::vector<Rect<int>> damagedRects;
+
+ // Actor added, damaged rect is added size of actor
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+ // Aligned by 16
+ Rect<int> clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Remove the Renderer
+ Renderer renderer = actor.GetRendererAt(0);
+ actor.RemoveRenderer(renderer);
+
+ application.SendNotification();
+
+ // The damaged rect should be the actor area
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_CHECK(damagedRects.size() > 0);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+ // Ensure the damaged rect is empty
+ DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+
+ // Add the Renderer again
+ actor.AddRenderer(renderer);
+
+ application.SendNotification();
+
+ // The damaged rect should be the actor area
+ damagedRects.clear();
+ application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+ application.RenderWithPartialUpdate(damagedRects, clippingRect);
+ DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliActorCaptureAllTouchAfterStartPropertyP(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ DALI_TEST_EQUALS(actor.GetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START).Get<bool>(), false, TEST_LOCATION);
+ actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, true);
+ DALI_TEST_EQUALS(actor.GetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START).Get<bool>(), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetPropertyType(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), Property::BOOLEAN, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.IsPropertyWritable(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.IsPropertyAnimatable(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.IsPropertyAConstraintInput(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetPropertyName(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), "captureAllTouchAfterStart", TEST_LOCATION);
+ END_TEST;
+}
+
+int UtcDaliActorCaptureAllTouchAfterStartPropertyN(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ // Make sure setting invalid types does not cause a crash
+ try
+ {
+ actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, 1.0f);
+ actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector2::ONE);
+ actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector3::ONE);
+ actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector4::ONE);
+ actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Property::Map());
+ actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Property::Array());
+ tet_result(TET_PASS);
+ }
+ catch(...)
+ {
+ tet_result(TET_FAIL);
+ }
+ END_TEST;
+}
+
+int UtcDaliActorTouchAreaOffsetPropertyP(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ Rect<int> touchAreaOffset = actor.GetProperty(DevelActor::Property::TOUCH_AREA_OFFSET).Get<Rect<int>>();
+ DALI_TEST_EQUALS(Rect<int>(0, 0, 0, 0), touchAreaOffset, TEST_LOCATION);
+ actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Rect<int>(10, 20, 30, 40));
+ touchAreaOffset = actor.GetProperty(DevelActor::Property::TOUCH_AREA_OFFSET).Get<Rect<int>>();
+ DALI_TEST_EQUALS(Rect<int>(10, 20, 30, 40), touchAreaOffset, TEST_LOCATION);
+ END_TEST;
+}
+
+int UtcDaliActorTouchAreaOffsetPropertyN(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ // Make sure setting invalid types does not cause a crash
+ try
+ {
+ actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, 1.0f);
+ actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Vector2::ONE);
+ actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Vector3::ONE);
+ actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Vector4::ONE);
+ actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Property::Map());
+ actor.SetProperty(DevelActor::Property::TOUCH_AREA_OFFSET, Property::Array());
+ tet_result(TET_PASS);
+ }
+ catch(...)
+ {
+ tet_result(TET_FAIL);
+ }
+ END_TEST;
+}
+
+int UtcDaliActorLowerBelowNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Actor arg1;
+ instance.LowerBelow(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRaiseAboveNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Actor arg1;
+ instance.RaiseAbove(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRaiseToTopNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.RaiseToTop();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
END_TEST;
}
END_TEST;
}
-int UtcDaliActorScaleByNegative(void)
+int UtcDaliActorScaleByNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Vector3 arg1;
+ instance.ScaleBy(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetLayerNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.GetLayer();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRotateByNegative01(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Quaternion arg1;
+ instance.RotateBy(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRotateByNegative02(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Radian arg1;
+ Dali::Vector3 arg2;
+ instance.RotateBy(arg1, arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorUnparentNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.Unparent();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetChildAtNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ unsigned int arg1 = 0u;
+ instance.GetChildAt(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetChildCountNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.GetChildCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetTargetSizeNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.GetTargetSize();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorScreenToLocalNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ float arg1 = 0.0f;
+ float arg2 = 0.0f;
+ float arg3 = 0.0f;
+ float arg4 = 0.0f;
+ instance.ScreenToLocal(arg1, arg2, arg3, arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetNaturalSizeNegative(void)
{
TestApplication application;
Dali::Actor instance;
try
{
- Dali::Vector3 arg1;
- instance.ScaleBy(arg1);
+ instance.GetNaturalSize();
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
END_TEST;
}
-int UtcDaliActorGetLayerNegative(void)
+int UtcDaliActorGetRelayoutSizeNegative(void)
{
TestApplication application;
Dali::Actor instance;
try
{
- instance.GetLayer();
+ Dali::Dimension::Type arg1 = Dimension::HEIGHT;
+ instance.GetRelayoutSize(arg1);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
END_TEST;
}
-int UtcDaliActorRotateByNegative01(void)
+int UtcDaliActorGetResizePolicyNegative(void)
{
TestApplication application;
Dali::Actor instance;
try
{
- Dali::Quaternion arg1;
- instance.RotateBy(arg1);
+ Dali::Dimension::Type arg1 = Dimension::ALL_DIMENSIONS;
+ instance.GetResizePolicy(arg1);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
END_TEST;
}
-int UtcDaliActorRotateByNegative02(void)
+int UtcDaliActorGetRendererCountNegative(void)
{
TestApplication application;
Dali::Actor instance;
try
{
- Dali::Radian arg1;
- Dali::Vector3 arg2;
- instance.RotateBy(arg1, arg2);
+ instance.GetRendererCount();
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
END_TEST;
}
-int UtcDaliActorUnparentNegative(void)
+int UtcDaliActorGetParentNegative(void)
{
TestApplication application;
Dali::Actor instance;
try
{
- instance.Unparent();
+ instance.GetParent();
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
END_TEST;
}
-int UtcDaliActorGetChildAtNegative(void)
+int UtcDaliActorPropertyBlendEquation(void)
{
TestApplication application;
- Dali::Actor instance;
- try
+
+ tet_infoline("Test SetProperty AdvancedBlendEquation");
+
+ Geometry geometry = CreateQuadGeometry();
+ Shader shader = CreateShader();
+ Renderer renderer1 = Renderer::New(geometry, shader);
+
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::OPACITY, 0.1f);
+
+ actor.AddRenderer(renderer1);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400, 400));
+ application.GetScene().Add(actor);
+
+ if(!Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN))
{
- unsigned int arg1 = 0u;
- instance.GetChildAt(arg1);
- DALI_TEST_CHECK(false); // Should not get here
+ actor.SetProperty(Dali::DevelActor::Property::BLEND_EQUATION, Dali::DevelBlendEquation::SCREEN);
+ int equation = actor.GetProperty<int>(Dali::DevelActor::Property::BLEND_EQUATION);
+ DALI_TEST_EQUALS((Dali::DevelBlendEquation::SCREEN == equation), false, TEST_LOCATION);
}
- catch(...)
+
+ if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN))
{
- DALI_TEST_CHECK(true); // We expect an assert
+ actor.SetProperty(Dali::DevelActor::Property::BLEND_EQUATION, Dali::DevelBlendEquation::SCREEN);
+ int equation = actor.GetProperty<int>(Dali::DevelActor::Property::BLEND_EQUATION);
+ DALI_TEST_EQUALS((Dali::DevelBlendEquation::SCREEN == equation), true, TEST_LOCATION);
}
+
+ Renderer renderer2 = Renderer::New(geometry, shader);
+ actor.AddRenderer(renderer2);
+
END_TEST;
}
-int UtcDaliActorGetChildCountNegative(void)
+int UtcDaliActorRegisterProperty(void)
{
+ tet_infoline("Test property registration and uniform map update\n");
+
TestApplication application;
- Dali::Actor instance;
- try
+
+ Geometry geometry = CreateQuadGeometry();
+ Shader shader = CreateShader();
+ Renderer renderer1 = Renderer::New(geometry, shader);
+ Renderer renderer2 = Renderer::New(geometry, shader);
+
+ Actor actor1 = Actor::New();
+ actor1.AddRenderer(renderer1);
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
+ actor1.RegisterProperty("uCustom", 1);
+ application.GetScene().Add(actor1);
+
+ Actor actor2 = Actor::New();
+ actor2.AddRenderer(renderer2);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
+ application.GetScene().Add(actor2);
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& callStack = glAbstraction.GetSetUniformTrace();
+ glAbstraction.EnableSetUniformCallTrace(true);
+
+ application.SendNotification();
+ application.Render();
+
+ std::stringstream out;
+ out.str("1");
+ std::string params;
+
+ // Test uniform value of the custom property
+ DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("uCustom", params));
+ DALI_TEST_EQUALS(out.str(), params, TEST_LOCATION);
+
+ // Make invisible
+ actor1[Actor::Property::VISIBLE] = false;
+
+ application.SendNotification();
+ application.Render();
+
+ // Make visible again
+ actor1[Actor::Property::VISIBLE] = true;
+ actor1["uCustom"] = 2;
+
+ glAbstraction.ResetSetUniformCallStack();
+
+ application.SendNotification();
+ application.Render();
+
+ out.str("2");
+
+ // The uniform value should not be changed
+ DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("uCustom", params));
+ DALI_TEST_EQUALS(out.str(), params, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliActorDoesWantedHitTest(void)
+{
+ struct HitTestData
{
- instance.GetChildCount();
- DALI_TEST_CHECK(false); // Should not get here
- }
- catch(...)
+ public:
+ HitTestData(const Vector3& scale, const Vector2& touchPoint, bool result)
+ : mScale(scale),
+ mTouchPoint(touchPoint),
+ mResult(result)
+ {
+ }
+
+ Vector3 mScale;
+ Vector2 mTouchPoint;
+ bool mResult;
+ };
+
+ TestApplication application;
+ tet_infoline(" UtcDaliActorDoesWantedHitTest");
+
+ // Fill a vector with different hit tests.
+ struct HitTestData* hitTestData[] = {
+ // scale touch point result
+ new HitTestData(Vector3(100.f, 100.f, 1.f), Vector2(289.f, 400.f), true), // touch point close to the right edge (inside)
+ new HitTestData(Vector3(100.f, 100.f, 1.f), Vector2(291.f, 400.f), false), // touch point close to the right edge (outside)
+ new HitTestData(Vector3(110.f, 100.f, 1.f), Vector2(291.f, 400.f), true), // same point as above with a wider scale. Should be inside.
+ new HitTestData(Vector3(100.f, 100.f, 1.f), Vector2(200.f, 451.f), false), // touch point close to the down edge (outside)
+ new HitTestData(Vector3(100.f, 110.f, 1.f), Vector2(200.f, 451.f), true), // same point as above with a wider scale. Should be inside.
+ NULL,
+ };
+
+ // get the root layer
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+
+ Actor lowerActor = Actor::New();
+ lowerActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ lowerActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+
+ // actor and lowerActor have no relationship.
+ application.GetScene().Add(lowerActor);
+ application.GetScene().Add(actor);
+
+ ResetTouchCallbacks();
+ gHitTestTouchCallBackCalled = false;
+
+ unsigned int index = 0;
+ while(NULL != hitTestData[index])
{
- DALI_TEST_CHECK(true); // We expect an assert
+ actor.SetProperty(Actor::Property::SIZE, Vector2(1.f, 1.f));
+ actor.SetProperty(Actor::Property::SCALE, Vector3(hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z));
+
+ lowerActor.SetProperty(Actor::Property::SIZE, Vector2(1.f, 1.f));
+ lowerActor.SetProperty(Actor::Property::SCALE, Vector3(hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z));
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_CHECK(!gTouchCallBackCalled);
+ DALI_TEST_CHECK(!gTouchCallBackCalled2);
+ DALI_TEST_CHECK(!gHitTestTouchCallBackCalled);
+
+ // connect to its touch signal
+ actor.TouchedSignal().Connect(TestTouchCallback);
+ lowerActor.TouchedSignal().Connect(TestTouchCallback2);
+
+ // connect to its hit-test signal
+ Dali::DevelActor::HitTestResultSignal(actor).Connect(TestHitTestTouchCallback);
+
+ Dali::Integration::Point point;
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y));
+ Dali::Integration::TouchEvent event;
+ event.AddPoint(point);
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+ application.ProcessEvent(event);
+
+ // check hit-test events
+ DALI_TEST_CHECK(gHitTestTouchCallBackCalled == hitTestData[index]->mResult);
+ // Passed all hit-tests of actor.
+ DALI_TEST_CHECK(gTouchCallBackCalled == false);
+ // The lowerActor was hit-tested.
+ DALI_TEST_CHECK(gTouchCallBackCalled2 == hitTestData[index]->mResult);
+
+ if(gTouchCallBackCalled2 != hitTestData[index]->mResult)
+ tet_printf("Test failed:\nScale %f %f %f\nTouchPoint %f, %f\nResult %d\n",
+ hitTestData[index]->mScale.x,
+ hitTestData[index]->mScale.y,
+ hitTestData[index]->mScale.z,
+ hitTestData[index]->mTouchPoint.x,
+ hitTestData[index]->mTouchPoint.y,
+ hitTestData[index]->mResult);
+
+ ResetTouchCallbacks();
+ gHitTestTouchCallBackCalled = false;
+ ++index;
}
END_TEST;
}
-int UtcDaliActorGetTargetSizeNegative(void)
+int UtcDaliActorAllowOnlyOwnTouchPropertyP(void)
{
TestApplication application;
- Dali::Actor instance;
+
+ Actor actor = Actor::New();
+ DALI_TEST_EQUALS(actor.GetProperty(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH).Get<bool>(), false, TEST_LOCATION);
+ actor.SetProperty(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH, true);
+ DALI_TEST_EQUALS(actor.GetProperty(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH).Get<bool>(), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetPropertyType(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH), Property::BOOLEAN, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.IsPropertyWritable(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.IsPropertyAnimatable(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.IsPropertyAConstraintInput(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetPropertyName(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH), "allowOnlyOwnTouch", TEST_LOCATION);
+ END_TEST;
+}
+
+int UtcDaliActorAllowOnlyOwnTouchPropertyN(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+
+ // Make sure setting invalid types does not cause a crash
try
{
- instance.GetTargetSize();
- DALI_TEST_CHECK(false); // Should not get here
+ actor.SetProperty(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH, 1.0f);
+ actor.SetProperty(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH, Vector2::ONE);
+ actor.SetProperty(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH, Vector3::ONE);
+ actor.SetProperty(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH, Vector4::ONE);
+ actor.SetProperty(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH, Property::Map());
+ actor.SetProperty(DevelActor::Property::ALLOW_ONLY_OWN_TOUCH, Property::Array());
+ tet_result(TET_PASS);
}
catch(...)
{
- DALI_TEST_CHECK(true); // We expect an assert
+ tet_result(TET_FAIL);
}
END_TEST;
}
-int UtcDaliActorScreenToLocalNegative(void)
+int UtcDaliActorCalculateWorldTransform01(void)
+{
+ TestApplication application;
+
+ tet_infoline("Test that actor position inheritance produces right transform matrix");
+
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
+
+ rootActor[Actor::Property::POSITION] = Vector3(0.0f, 0.0f, 0.0f);
+ branchActor[Actor::Property::POSITION] = Vector3(100.0f, 100.0f, 0.0f);
+ leafActor[Actor::Property::POSITION] = Vector3(100.0f, 50.0f, 30.0f);
+
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+
+ // Set anchor point to the same value as parent origin
+ rootActor[Actor::Property::PARENT_ORIGIN] = ParentOrigin::TOP_LEFT;
+ branchActor[Actor::Property::PARENT_ORIGIN] = ParentOrigin::TOP_LEFT;
+ leafActor[Actor::Property::PARENT_ORIGIN] = ParentOrigin::TOP_LEFT;
+
+ rootActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ branchActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ leafActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
+
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+
+ Matrix m = DevelActor::GetWorldTransform(leafActor);
+
+ Matrix actualMatrix = leafActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
+ DALI_TEST_EQUALS(m, actualMatrix, 0.001f, TEST_LOCATION);
+
+ Vector3 worldPos;
+ Vector3 worldScale;
+ Quaternion worldRotation;
+ m.GetTransformComponents(worldPos, worldRotation, worldScale);
+ DALI_TEST_EQUALS(worldPos, Vector3(200.0f, 150.0f, 30.0f), 0.0001f, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliActorCalculateWorldTransform02(void)
+{
+ TestApplication application;
+
+ tet_infoline("Test that actor position produces right transform matrix");
+
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
+
+ rootActor[Actor::Property::POSITION] = Vector3(0.0f, 0.0f, 0.0f);
+ branchActor[Actor::Property::POSITION] = Vector3(100.0f, 100.0f, 0.0f);
+ leafActor[Actor::Property::POSITION] = Vector3(100.0f, 50.0f, 30.0f);
+
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+
+ // Set anchor point to the same value as parent origin
+ rootActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ branchActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ leafActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
+
+ leafActor[Actor::Property::INHERIT_POSITION] = false;
+ leafActor[Actor::Property::INHERIT_ORIENTATION] = false;
+ leafActor[Actor::Property::INHERIT_SCALE] = false;
+
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+
+ Matrix m = DevelActor::GetWorldTransform(leafActor);
+
+ Matrix actualMatrix = leafActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
+ DALI_TEST_EQUALS(m, actualMatrix, 0.001f, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliActorCalculateWorldTransform03(void)
{
TestApplication application;
- Dali::Actor instance;
- try
- {
- float arg1 = 0.0f;
- float arg2 = 0.0f;
- float arg3 = 0.0f;
- float arg4 = 0.0f;
- instance.ScreenToLocal(arg1, arg2, arg3, arg4);
- DALI_TEST_CHECK(false); // Should not get here
- }
- catch(...)
- {
- DALI_TEST_CHECK(true); // We expect an assert
- }
+
+ tet_infoline("Test that actor position produces right transform matrix");
+
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
+
+ rootActor[Actor::Property::POSITION] = Vector3(0.0f, 0.0f, 0.0f);
+ branchActor[Actor::Property::POSITION] = Vector3(100.0f, 100.0f, 0.0f);
+ leafActor[Actor::Property::POSITION] = Vector3(100.0f, 50.0f, 30.0f);
+
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+
+ // Set anchor point to the same value as parent origin
+ rootActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ branchActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ leafActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
+
+ leafActor[Actor::Property::INHERIT_POSITION] = true;
+ leafActor[Actor::Property::INHERIT_ORIENTATION] = false;
+ leafActor[Actor::Property::INHERIT_SCALE] = false;
+
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+
+ Matrix m = DevelActor::GetWorldTransform(leafActor);
+
+ Matrix actualMatrix = leafActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
+ DALI_TEST_EQUALS(m, actualMatrix, 0.001f, TEST_LOCATION);
+
END_TEST;
}
-int UtcDaliActorGetNaturalSizeNegative(void)
+int UtcDaliActorCalculateWorldTransform04(void)
{
TestApplication application;
- Dali::Actor instance;
- try
- {
- instance.GetNaturalSize();
- DALI_TEST_CHECK(false); // Should not get here
- }
- catch(...)
- {
- DALI_TEST_CHECK(true); // We expect an assert
- }
+
+ tet_infoline("Test that actor inheritance scale/orientation produces right transform matrix");
+
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
+
+ rootActor[Actor::Property::POSITION] = Vector3(100.0f, 0.0f, 0.0f);
+ rootActor[Actor::Property::SCALE] = Vector3(2.0f, 2.0f, 2.0f);
+ rootActor[Actor::Property::ORIENTATION] = AngleAxis(Degree(90.0f), Vector3::ZAXIS);
+
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+
+ // Set anchor point to the same value as parent origin
+ rootActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::CENTER;
+ rootActor[Actor::Property::PARENT_ORIGIN] = ParentOrigin::CENTER;
+ branchActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ leafActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+
+ branchActor[Actor::Property::POSITION] = Vector3(100.0f, 100.0f, 0.0f);
+ leafActor[Actor::Property::POSITION] = Vector3(100.0f, 50.0f, 30.0f);
+
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
+
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+
+ Matrix m = DevelActor::GetWorldTransform(leafActor);
+
+ Matrix actualMatrix = leafActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
+ DALI_TEST_EQUALS(m, actualMatrix, 0.001f, TEST_LOCATION);
+
END_TEST;
}
-int UtcDaliActorGetRelayoutSizeNegative(void)
+int UtcDaliActorCalculateWorldTransform05(void)
{
TestApplication application;
- Dali::Actor instance;
- try
- {
- Dali::Dimension::Type arg1 = Dimension::HEIGHT;
- instance.GetRelayoutSize(arg1);
- DALI_TEST_CHECK(false); // Should not get here
- }
- catch(...)
- {
- DALI_TEST_CHECK(true); // We expect an assert
- }
+
+ tet_infoline("Test that actor inheritance of scale produces right transform matrix");
+
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
+
+ rootActor[Actor::Property::POSITION] = Vector3(100.0f, 0.0f, 0.0f);
+ rootActor[Actor::Property::SCALE] = Vector3(2.0f, 2.0f, 2.0f);
+ rootActor[Actor::Property::ORIENTATION] = AngleAxis(Degree(90.0f), Vector3::ZAXIS);
+
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+
+ // Set anchor point to the same value as parent origin
+ rootActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::CENTER;
+ rootActor[Actor::Property::PARENT_ORIGIN] = ParentOrigin::CENTER;
+ branchActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ leafActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+
+ branchActor[Actor::Property::POSITION] = Vector3(100.0f, 100.0f, 0.0f);
+ leafActor[Actor::Property::POSITION] = Vector3(100.0f, 50.0f, 30.0f);
+
+ leafActor[Actor::Property::INHERIT_POSITION] = false;
+ leafActor[Actor::Property::INHERIT_ORIENTATION] = false;
+
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
+
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+
+ Matrix m = DevelActor::GetWorldTransform(leafActor);
+
+ Matrix actualMatrix = leafActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
+ DALI_TEST_EQUALS(m, actualMatrix, 0.001f, TEST_LOCATION);
+
END_TEST;
}
-int UtcDaliActorGetResizePolicyNegative(void)
+int UtcDaliActorCalculateWorldTransform06(void)
{
TestApplication application;
- Dali::Actor instance;
- try
- {
- Dali::Dimension::Type arg1 = Dimension::ALL_DIMENSIONS;
- instance.GetResizePolicy(arg1);
- DALI_TEST_CHECK(false); // Should not get here
- }
- catch(...)
- {
- DALI_TEST_CHECK(true); // We expect an assert
- }
+
+ tet_infoline("Test that actor inheritance of scale produces right transform matrix");
+
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
+
+ rootActor[Actor::Property::POSITION] = Vector3(100.0f, 0.0f, 0.0f);
+ rootActor[Actor::Property::SCALE] = Vector3(2.0f, 2.0f, 2.0f);
+ rootActor[Actor::Property::ORIENTATION] = AngleAxis(Degree(90.0f), Vector3::ZAXIS);
+
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+
+ // Set anchor point to the same value as parent origin
+ rootActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::CENTER;
+ rootActor[Actor::Property::PARENT_ORIGIN] = ParentOrigin::CENTER;
+ branchActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ leafActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+
+ branchActor[Actor::Property::POSITION] = Vector3(100.0f, 30.0f, -50.0f);
+ branchActor[Actor::Property::ORIENTATION] = AngleAxis(Degree(45.0f), Vector3::XAXIS);
+ leafActor[Actor::Property::POSITION] = Vector3(100.0f, 50.0f, 30.0f);
+
+ leafActor[Actor::Property::INHERIT_POSITION] = false;
+ leafActor[Actor::Property::INHERIT_SCALE] = false;
+
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
+
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+
+ Matrix m = DevelActor::GetWorldTransform(leafActor);
+
+ Matrix actualMatrix = leafActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
+ DALI_TEST_EQUALS(m, actualMatrix, 0.001f, TEST_LOCATION);
+
END_TEST;
}
-int UtcDaliActorGetRendererCountNegative(void)
+int UtcDaliActorCalculateWorldTransform07(void)
{
TestApplication application;
- Dali::Actor instance;
- try
- {
- instance.GetRendererCount();
- DALI_TEST_CHECK(false); // Should not get here
- }
- catch(...)
- {
- DALI_TEST_CHECK(true); // We expect an assert
- }
+
+ tet_infoline("Test that actor inheritance of scale produces right transform matrix");
+
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
+
+ rootActor[Actor::Property::POSITION] = Vector3(100.0f, 0.0f, 0.0f);
+ rootActor[Actor::Property::SCALE] = Vector3(2.0f, 2.0f, 2.0f);
+ rootActor[Actor::Property::ORIENTATION] = AngleAxis(Degree(90.0f), Vector3::ZAXIS);
+
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+
+ // Set anchor point to the same value as parent origin
+ rootActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::CENTER;
+ rootActor[Actor::Property::PARENT_ORIGIN] = ParentOrigin::CENTER;
+ branchActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+
+ // This should be ignored.
+ leafActor[Actor::Property::PARENT_ORIGIN] = ParentOrigin::CENTER;
+ leafActor[Actor::Property::ANCHOR_POINT] = AnchorPoint::CENTER;
+
+ branchActor[Actor::Property::POSITION] = Vector3(100.0f, 30.0f, -50.0f);
+ branchActor[Actor::Property::ORIENTATION] = AngleAxis(Degree(45.0f), Vector3::XAXIS);
+ leafActor[Actor::Property::POSITION] = Vector3(100.0f, 50.0f, 30.0f);
+
+ leafActor[Actor::Property::INHERIT_POSITION] = false;
+ leafActor[Actor::Property::INHERIT_SCALE] = false;
+ leafActor[Actor::Property::POSITION_USES_ANCHOR_POINT] = false;
+
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
+
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+
+ Matrix m = DevelActor::GetWorldTransform(leafActor);
+
+ Matrix actualMatrix = leafActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
+ DALI_TEST_EQUALS(m, actualMatrix, 0.001f, TEST_LOCATION);
+
END_TEST;
}
-int UtcDaliActorGetParentNegative(void)
+int UtcDaliActorCalculateWorldColor01(void)
{
TestApplication application;
- Dali::Actor instance;
- try
- {
- instance.GetParent();
- DALI_TEST_CHECK(false); // Should not get here
- }
- catch(...)
- {
- DALI_TEST_CHECK(true); // We expect an assert
- }
+
+ tet_infoline("Test that actor inheritance of color produces right final color");
+
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
+
+ rootActor[Actor::Property::POSITION] = Vector3(100.0f, 0.0f, 0.0f);
+ rootActor[Actor::Property::SCALE] = Vector3(2.0f, 2.0f, 2.0f);
+ rootActor[Actor::Property::ORIENTATION] = AngleAxis(Degree(90.0f), Vector3::ZAXIS);
+
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+
+ rootActor[Actor::Property::COLOR] = Color::WHITE;
+ branchActor[Actor::Property::COLOR] = Vector4(1.0f, 1.0f, 0.5f, 0.8f);
+ leafActor[Actor::Property::COLOR] = Vector4(0.1f, 0.5f, 0.5f, 0.8f);
+
+ // Default is to inherit:
+ leafActor[Actor::Property::COLOR_MODE] = ColorMode::USE_OWN_MULTIPLY_PARENT_ALPHA;
+
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
+
+ application.SendNotification();
+ application.Render(0);
+
+ Vector4 color = DevelActor::GetWorldColor(leafActor);
+
+ Vector4 actualColor = leafActor.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR);
+ DALI_TEST_EQUALS(color, actualColor, 0.001f, TEST_LOCATION);
+
END_TEST;
}
-int UtcDaliActorPropertyBlendEquation(void)
+int UtcDaliActorCalculateWorldColor02(void)
{
TestApplication application;
- tet_infoline("Test SetProperty AdvancedBlendEquation");
+ tet_infoline("Test that actor uses own color");
- Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer1 = Renderer::New(geometry, shader);
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
- Actor actor = Actor::New();
- actor.SetProperty(Actor::Property::OPACITY, 0.1f);
+ rootActor[Actor::Property::POSITION] = Vector3(100.0f, 0.0f, 0.0f);
+ rootActor[Actor::Property::SCALE] = Vector3(2.0f, 2.0f, 2.0f);
+ rootActor[Actor::Property::ORIENTATION] = AngleAxis(Degree(90.0f), Vector3::ZAXIS);
- actor.AddRenderer(renderer1);
- actor.SetProperty(Actor::Property::SIZE, Vector2(400, 400));
- application.GetScene().Add(actor);
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
- if(!Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN))
- {
- actor.SetProperty(Dali::DevelActor::Property::BLEND_EQUATION, Dali::DevelBlendEquation::SCREEN);
- int equation = actor.GetProperty<int>(Dali::DevelActor::Property::BLEND_EQUATION);
- DALI_TEST_EQUALS((Dali::DevelBlendEquation::SCREEN == equation), false, TEST_LOCATION);
- }
+ rootActor[Actor::Property::COLOR] = Color::WHITE;
+ branchActor[Actor::Property::COLOR] = Vector4(1.0f, 1.0f, 0.5f, 0.8f);
+ leafActor[Actor::Property::COLOR] = Vector4(0.1f, 0.5f, 0.5f, 0.8f);
- if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN))
- {
- actor.SetProperty(Dali::DevelActor::Property::BLEND_EQUATION, Dali::DevelBlendEquation::SCREEN);
- int equation = actor.GetProperty<int>(Dali::DevelActor::Property::BLEND_EQUATION);
- DALI_TEST_EQUALS((Dali::DevelBlendEquation::SCREEN == equation), true, TEST_LOCATION);
- }
+ leafActor[Actor::Property::COLOR_MODE] = ColorMode::USE_OWN_COLOR;
- Renderer renderer2 = Renderer::New(geometry, shader);
- actor.AddRenderer(renderer2);
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
+ application.SendNotification();
+ application.Render(0);
+
+ Vector4 color = DevelActor::GetWorldColor(leafActor);
+
+ Vector4 actualColor = leafActor.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR);
+ DALI_TEST_EQUALS(color, actualColor, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(color, Vector4(0.1f, 0.5f, 0.5f, 0.8f), 0.001f, TEST_LOCATION);
END_TEST;
}
-int UtcDaliActorRegisterProperty(void)
+int UtcDaliActorCalculateWorldColor03(void)
{
- tet_infoline("Test property registration and uniform map update\n");
-
TestApplication application;
- Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer1 = Renderer::New(geometry, shader);
- Renderer renderer2 = Renderer::New(geometry, shader);
+ tet_infoline("Test that actor uses parent color");
- Actor actor1 = Actor::New();
- actor1.AddRenderer(renderer1);
- actor1.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
- actor1.RegisterProperty("uCustom", 1);
- application.GetScene().Add(actor1);
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
- Actor actor2 = Actor::New();
- actor2.AddRenderer(renderer2);
- actor2.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
- application.GetScene().Add(actor2);
+ rootActor[Actor::Property::POSITION] = Vector3(100.0f, 0.0f, 0.0f);
+ rootActor[Actor::Property::SCALE] = Vector3(2.0f, 2.0f, 2.0f);
+ rootActor[Actor::Property::ORIENTATION] = AngleAxis(Degree(90.0f), Vector3::ZAXIS);
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& callStack = glAbstraction.GetSetUniformTrace();
- glAbstraction.EnableSetUniformCallTrace(true);
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+
+ rootActor[Actor::Property::COLOR] = Color::WHITE * 0.9f;
+ branchActor[Actor::Property::COLOR] = Vector4(1.0f, 1.0f, 0.5f, 0.8f);
+ leafActor[Actor::Property::COLOR] = Vector4(0.1f, 0.5f, 0.5f, 0.8f);
+
+ leafActor[Actor::Property::COLOR_MODE] = ColorMode::USE_PARENT_COLOR;
+
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
application.SendNotification();
- application.Render();
+ application.Render(0);
- std::stringstream out;
- out.str("1");
- std::string params;
+ Vector4 color = DevelActor::GetWorldColor(leafActor);
- // Test uniform value of the custom property
- DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("uCustom", params));
- DALI_TEST_EQUALS(out.str(), params, TEST_LOCATION);
+ Vector4 actualColor = leafActor.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR);
+ DALI_TEST_EQUALS(color, actualColor, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(color, Vector4(1.0f, 1.0f, 0.5f, 0.72f), 0.001f, TEST_LOCATION);
+ END_TEST;
+}
- // Make invisible
- actor1[Actor::Property::VISIBLE] = false;
+int UtcDaliActorCalculateWorldColor04(void)
+{
+ TestApplication application;
- application.SendNotification();
- application.Render();
+ tet_infoline("Test that actor blends with parent color");
- // Make visible again
- actor1[Actor::Property::VISIBLE] = true;
- actor1["uCustom"] = 2;
+ Actor rootActor = Actor::New();
+ Actor branchActor = Actor::New();
+ Actor leafActor = Actor::New();
- glAbstraction.ResetSetUniformCallStack();
+ rootActor[Actor::Property::POSITION] = Vector3(100.0f, 0.0f, 0.0f);
+ rootActor[Actor::Property::SCALE] = Vector3(2.0f, 2.0f, 2.0f);
+ rootActor[Actor::Property::ORIENTATION] = AngleAxis(Degree(90.0f), Vector3::ZAXIS);
+
+ rootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ branchActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ leafActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+
+ rootActor[Actor::Property::COLOR] = Color::WHITE * 0.9f;
+ branchActor[Actor::Property::COLOR] = Vector4(1.0f, 1.0f, 0.5f, 0.8f);
+ leafActor[Actor::Property::COLOR] = Vector4(0.1f, 0.5f, 0.5f, 0.8f);
+
+ leafActor[Actor::Property::COLOR_MODE] = ColorMode::USE_OWN_MULTIPLY_PARENT_COLOR;
+
+ application.GetScene().Add(rootActor);
+ rootActor.Add(branchActor);
+ branchActor.Add(leafActor);
application.SendNotification();
- application.Render();
+ application.Render(0);
- out.str("2");
+ Vector4 color = DevelActor::GetWorldColor(leafActor);
- // The uniform value should not be changed
- DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("uCustom", params));
- DALI_TEST_EQUALS(out.str(), params, TEST_LOCATION);
+ Vector4 actualColor = leafActor.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR);
+ DALI_TEST_EQUALS(color, actualColor, 0.001f, TEST_LOCATION);
END_TEST;
}
projects / platform / core / uifw / dali-core.git / blobdiff