DALI_TEST_EQUALS(expectedRectList.empty(), true, testLocation);
}
+// Clipping test helper functions:
+Actor CreateActorWithContent(uint32_t width, uint32_t height)
+{
+ Texture image = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ Actor actor = CreateRenderableActor(image);
+
+ // Setup dimensions and position so actor is not skipped by culling.
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(width, height));
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+
+ return actor;
+}
+
+Actor CreateActorWithContent16x16()
+{
+ return CreateActorWithContent(16, 16);
+}
+
+void GenerateTrace(TestApplication& application, TraceCallStack& enabledDisableTrace, TraceCallStack& callTrace)
+{
+ enabledDisableTrace.Reset();
+ callTrace.Reset();
+ enabledDisableTrace.Enable(true);
+ callTrace.Enable(true);
+
+ application.SendNotification();
+ application.Render();
+
+ enabledDisableTrace.Enable(false);
+ callTrace.Enable(false);
+}
+
+void CheckColorMask(TestGlAbstraction& glAbstraction, bool maskValue)
+{
+ const TestGlAbstraction::ColorMaskParams& colorMaskParams = glAbstraction.GetColorMaskParams();
+
+ DALI_TEST_EQUALS<bool>(colorMaskParams.red, maskValue, TEST_LOCATION);
+ DALI_TEST_EQUALS<bool>(colorMaskParams.green, maskValue, TEST_LOCATION);
+ DALI_TEST_EQUALS<bool>(colorMaskParams.blue, maskValue, TEST_LOCATION);
+
+ // @todo only test alpha if the framebuffer has an alpha channel
+ //DALI_TEST_EQUALS<bool>(colorMaskParams.alpha, maskValue, TEST_LOCATION);
+}
+
} // anonymous namespace
//& purpose: Testing New API
END_TEST;
}
+int UtcDaliActorSetDrawModeOverlayWithClipping(void)
+{
+ TestApplication application;
+ tet_infoline(" UtcDaliActorSetDrawModeOverlayWithClipping");
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+ const Vector2 surfaceSize(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
+ const Vector2 imageSize(16.0f, 16.0f);
+
+ std::vector<GLuint> ids;
+ ids.push_back(8); // first rendered actor
+ ids.push_back(9); // second rendered actor
+ ids.push_back(10); // third rendered actor
+ ids.push_back(11); // forth rendered actor
+ application.GetGlAbstraction().SetNextTextureIds(ids);
+
+ Actor a = CreateActorWithContent16x16();
+ Actor b = CreateActorWithContent16x16();
+ Actor c = CreateActorWithContent16x16();
+ Actor d = CreateActorWithContent16x16();
+
+ application.SendNotification();
+ application.Render();
+
+ //Textures are bound when first created. Clear bound textures vector
+ application.GetGlAbstraction().ClearBoundTextures();
+
+ b[Actor::Property::PARENT_ORIGIN] = ParentOrigin::BOTTOM_LEFT;
+ b[Actor::Property::ANCHOR_POINT] = AnchorPoint::BOTTOM_LEFT;
+ b[Actor::Property::DRAW_MODE] = DrawMode::OVERLAY_2D;
+ b[Actor::Property::CLIPPING_MODE] = ClippingMode::CLIP_TO_BOUNDING_BOX;
+
+ c[Actor::Property::PARENT_ORIGIN] = ParentOrigin::BOTTOM_LEFT;
+ c[Actor::Property::ANCHOR_POINT] = AnchorPoint::BOTTOM_LEFT;
+ c[Actor::Property::CLIPPING_MODE] = ClippingMode::CLIP_TO_BOUNDING_BOX;
+ c[Actor::Property::POSITION] = Vector2(100.0f, -100.0f);
+
+ application.GetScene().Add(a);
+ application.GetScene().Add(b);
+ application.GetScene().Add(c);
+ b.Add(d);
+
+ GenerateTrace(application, enabledDisableTrace, scissorTrace);
+
+ const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures(GL_TEXTURE0);
+ typedef std::vector<GLuint>::size_type TextureSize;
+ DALI_TEST_EQUALS(boundTextures.size(), static_cast<TextureSize>(4), TEST_LOCATION);
+ if(boundTextures.size() == 4)
+ {
+ DALI_TEST_CHECK(boundTextures[0] == 8u);
+ DALI_TEST_CHECK(boundTextures[1] == 10u);
+ DALI_TEST_CHECK(boundTextures[2] == 9u);
+ DALI_TEST_CHECK(boundTextures[3] == 11u);
+ }
+
+ // Check scissor test was enabled.
+ std::ostringstream scissor;
+ scissor << std::hex << GL_SCISSOR_TEST;
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
+
+ // Check the scissor was set, and the coordinates are correct.
+ DALI_TEST_CHECK(scissorTrace.TestMethodAndParams(0, "Scissor", "100, 100, 16, 16")); // First compare with c area
+ DALI_TEST_CHECK(scissorTrace.TestMethodAndParams(1, "Scissor", "0, 0, 16, 16")); // Second compare with b area
+
+ application.GetGlAbstraction().ClearBoundTextures();
+
+ // Remove a Renderer of overlay actor
+ Renderer renderer = b.GetRendererAt(0);
+ b.RemoveRenderer(renderer);
+
+ GenerateTrace(application, enabledDisableTrace, scissorTrace);
+
+ DALI_TEST_EQUALS(boundTextures.size(), static_cast<TextureSize>(3), TEST_LOCATION);
+ if(boundTextures.size() == 3)
+ {
+ DALI_TEST_CHECK(boundTextures[0] == 8u);
+ DALI_TEST_CHECK(boundTextures[1] == 10u);
+ DALI_TEST_CHECK(boundTextures[2] == 11u);
+ }
+
+ DALI_TEST_CHECK(scissorTrace.TestMethodAndParams(0, "Scissor", "100, 100, 16, 16")); // First compare with c area
+ DALI_TEST_CHECK(scissorTrace.TestMethodAndParams(1, "Scissor", "0, 0, 16, 16")); // Second compare with b area
+
+ END_TEST;
+}
+
int UtcDaliActorGetCurrentWorldMatrix(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliActorRemoveRendererN(void)
+int UtcDaliActorRemoveRendererP3(void)
{
tet_infoline("Testing Actor::RemoveRenderer");
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor1 = Actor::New();
+ Actor actor2 = Actor::New();
+ Actor actor3 = Actor::New();
- DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
+ application.GetScene().Add(actor1);
+ application.GetScene().Add(actor2);
+ application.GetScene().Add(actor3);
- Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New(geometry, shader);
+ // Make each actors size bigger than zero, so we can assuem that actor is rendered
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+ actor3.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
- actor.AddRenderer(renderer);
- DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
+ // Register some dummy property to seperate actor1 and actor2 in Render::Renderer
+ actor1.RegisterProperty("dummy1", 1);
+ actor2.RegisterProperty("dummy2", 2.0f);
+ actor3.RegisterProperty("dummy3", Vector2(3.0f, 4.0f));
- actor.RemoveRenderer(10);
- DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
- DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor1.GetRendererCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor2.GetRendererCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor3.GetRendererCount(), 0u, TEST_LOCATION);
- END_TEST;
-}
+ Geometry geometry = CreateQuadGeometry();
+ Shader shader = CreateShader();
+ Renderer renderer1 = Renderer::New(geometry, shader);
+ Renderer renderer2 = Renderer::New(geometry, shader);
-// Clipping test helper functions:
-Actor CreateActorWithContent(uint32_t width, uint32_t height)
-{
- Texture image = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
- Actor actor = CreateRenderableActor(image);
+ actor1.AddRenderer(renderer1);
+ actor1.AddRenderer(renderer2);
+ actor2.AddRenderer(renderer1);
+ actor2.AddRenderer(renderer2);
+ actor3.AddRenderer(renderer1);
+ actor3.AddRenderer(renderer2);
+ application.SendNotification();
+ application.Render();
- // Setup dimensions and position so actor is not skipped by culling.
- actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
- actor.SetProperty(Actor::Property::SIZE, Vector2(width, height));
- actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ DALI_TEST_EQUALS(actor1.GetRendererCount(), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor1.GetRendererAt(0), renderer1, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor1.GetRendererAt(1), renderer2, TEST_LOCATION);
- return actor;
-}
+ DALI_TEST_EQUALS(actor2.GetRendererCount(), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor2.GetRendererAt(0), renderer1, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor2.GetRendererAt(1), renderer2, TEST_LOCATION);
-Actor CreateActorWithContent16x16()
-{
- return CreateActorWithContent(16, 16);
-}
-
-void GenerateTrace(TestApplication& application, TraceCallStack& enabledDisableTrace, TraceCallStack& stencilTrace)
-{
- enabledDisableTrace.Reset();
- stencilTrace.Reset();
- enabledDisableTrace.Enable(true);
- stencilTrace.Enable(true);
+ DALI_TEST_EQUALS(actor3.GetRendererCount(), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor3.GetRendererAt(0), renderer1, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor3.GetRendererAt(1), renderer2, TEST_LOCATION);
+ actor1.RemoveRenderer(0);
+ actor2.RemoveRenderer(1);
+ actor3.RemoveRenderer(0);
application.SendNotification();
application.Render();
- enabledDisableTrace.Enable(false);
- stencilTrace.Enable(false);
+ DALI_TEST_EQUALS(actor1.GetRendererCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor1.GetRendererAt(0), renderer2, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor2.GetRendererCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor2.GetRendererAt(0), renderer1, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor3.GetRendererCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor3.GetRendererAt(0), renderer2, TEST_LOCATION);
+
+ // Shut down whilst holding onto the renderer handle.
+ END_TEST;
}
-void CheckColorMask(TestGlAbstraction& glAbstraction, bool maskValue)
+int UtcDaliActorRemoveRendererN(void)
{
- const TestGlAbstraction::ColorMaskParams& colorMaskParams = glAbstraction.GetColorMaskParams();
+ tet_infoline("Testing Actor::RemoveRenderer");
+ TestApplication application;
- DALI_TEST_EQUALS<bool>(colorMaskParams.red, maskValue, TEST_LOCATION);
- DALI_TEST_EQUALS<bool>(colorMaskParams.green, maskValue, TEST_LOCATION);
- DALI_TEST_EQUALS<bool>(colorMaskParams.blue, maskValue, TEST_LOCATION);
+ Actor actor = Actor::New();
- // @todo only test alpha if the framebuffer has an alpha channel
- //DALI_TEST_EQUALS<bool>(colorMaskParams.alpha, maskValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
+
+ Geometry geometry = CreateQuadGeometry();
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
+
+ actor.AddRenderer(renderer);
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
+
+ actor.RemoveRenderer(10);
+ DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
+
+ END_TEST;
}
int UtcDaliActorPropertyClippingP(void)
END_TEST;
}
+int utcDaliActorGetSizeAfterAnimation2(void)
+{
+ TestApplication application;
+ tet_infoline("Check the actor size before / after an animation is finished if before size is equal to animation target size");
+
+ Vector3 actorSize(100.0f, 100.0f, 0.0f);
+
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, actorSize);
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ application.GetScene().Add(actor);
+
+ // Size should be updated without rendering.
+ Vector3 size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render();
+
+ // Size and current size should be updated.
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
+
+ Vector3 currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
+
+ // Set size again
+ actorSize = Vector3(200.0f, 200.0f, 0.0f);
+ actor.SetProperty(Actor::Property::SIZE, actorSize);
+
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+
+ Vector3 targetValue(actorSize);
+
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetValue);
+ animation.Play();
+
+ // Size should be updated without rendering.
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(100); // During the animation
+
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
+
+ // We should get target value because targetValue is equal to current actor size.
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(1000); // After animation finished
+
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+
+ END_TEST;
+}
+
int utcDaliActorRelayoutAndAnimation(void)
{
TestApplication application;
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);
+ rootActor[Actor::Property::COLOR] = Color::WHITE;
+ Vector4 testColor1(1.0f, 1.0f, 0.5f, 0.8f);
+ branchActor[Actor::Property::COLOR] = testColor1;
leafActor[Actor::Property::COLOR] = Vector4(0.1f, 0.5f, 0.5f, 0.8f);
// Default is to inherit:
branchActor.Add(leafActor);
application.SendNotification();
- application.Render(0);
+ application.Render(16);
+ Vector4 color = branchActor.GetCurrentProperty<Vector4>(Actor::Property::COLOR);
+ DALI_TEST_EQUALS(color, testColor1, TEST_LOCATION);
- Vector4 color = DevelActor::GetWorldColor(leafActor);
+ application.SendNotification();
+ application.Render(16);
+ color = branchActor.GetCurrentProperty<Vector4>(Actor::Property::COLOR);
+ DALI_TEST_EQUALS(color, testColor1, TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(16);
+ color = branchActor.GetCurrentProperty<Vector4>(Actor::Property::COLOR);
+ DALI_TEST_EQUALS(color, testColor1, TEST_LOCATION);
+
+ 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 UtcDaliActorCalculateLookAt(void)
+{
+ TestApplication application;
+
+ tet_infoline("Test that actor rotate right value of orientation");
+
+ Actor actor = Actor::New();
+
+ actor[Actor::Property::POSITION] = Vector3(100.0f, 0.0f, 0.0f);
+ actor[Actor::Property::ANCHOR_POINT] = AnchorPoint::CENTER;
+ actor[Actor::Property::PARENT_ORIGIN] = ParentOrigin::CENTER;
+
+ application.GetScene().Add(actor);
+
+ application.SendNotification();
+ application.Render(0);
+
+ Quaternion actorQuaternion;
+
+ tet_printf("Test with target only\n");
+ Dali::DevelActor::LookAt(actor, Vector3::ZERO);
+ actorQuaternion = actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+ DALI_TEST_EQUALS(actorQuaternion, Quaternion(Radian(Degree(90.0f)), Vector3::NEGATIVE_YAXIS), TEST_LOCATION);
+
+ tet_printf("Test with target + up\n");
+ Dali::DevelActor::LookAt(actor, Vector3::ZERO, Vector3::ZAXIS);
+ actorQuaternion = actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+ DALI_TEST_EQUALS(actorQuaternion, Quaternion(Radian(Degree(90.0f)), Vector3::XAXIS) * Quaternion(Radian(Degree(90.0f)), Vector3::NEGATIVE_YAXIS), TEST_LOCATION);
+
+ tet_printf("Test with target + up + localForward\n");
+ Dali::DevelActor::LookAt(actor, Vector3::ZERO, Vector3::NEGATIVE_YAXIS, Vector3::NEGATIVE_XAXIS);
+ actorQuaternion = actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+ DALI_TEST_EQUALS(actorQuaternion, Quaternion(Radian(Degree(180.0f)), Vector3::XAXIS), TEST_LOCATION);
+
+ tet_printf("Test with target + up + localForward + localUp\n");
+ Dali::DevelActor::LookAt(actor, Vector3::ZERO, Vector3::NEGATIVE_YAXIS, Vector3::NEGATIVE_YAXIS, Vector3::XAXIS);
+ actorQuaternion = actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+ DALI_TEST_EQUALS(actorQuaternion, Quaternion(Radian(Degree(90.0f)), Vector3::NEGATIVE_ZAXIS), TEST_LOCATION);
+
+ // Reset quaternion
+ actor[Actor::Property::ORIENTATION] = Quaternion();
+
+ Actor actor2 = Actor::New();
+ actor2[Actor::Property::POSITION] = Vector3(0.0f, 50.0f, -10.0f);
+ actor2[Actor::Property::ANCHOR_POINT] = AnchorPoint::CENTER;
+ actor2[Actor::Property::PARENT_ORIGIN] = ParentOrigin::CENTER;
+ actor.Add(actor2);
+
+ tet_printf("Test whether lookat calculate well by using event side values only\n");
+ Dali::DevelActor::LookAt(actor2, Vector3(100.0f, 50.0f, 1.0f));
+ actorQuaternion = actor2.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+ DALI_TEST_EQUALS(actorQuaternion, Quaternion(), TEST_LOCATION);
+
+ actor[Actor::Property::ORIENTATION] = Quaternion(Radian(Degree(90.0f)), Vector3::ZAXIS);
+
+ DALI_TEST_EQUALS(Dali::DevelActor::GetWorldTransform(actor2).GetTranslation3(), Vector3(50.0f, 0.0f, -10.0f), TEST_LOCATION);
+
+ tet_printf("Test whether lookat calculate well inherit by parent orientation\n");
+ Dali::DevelActor::LookAt(actor2, Vector3(50.0f, 0.0f, 1.0f), Vector3::NEGATIVE_XAXIS);
+ actorQuaternion = actor2.GetProperty<Quaternion>(Actor::Property::ORIENTATION);
+ DALI_TEST_EQUALS(actorQuaternion, Quaternion(), TEST_LOCATION);
+
+ END_TEST;
+}
projects / platform / core / uifw / dali-core.git / blobdiff