automated-tests/src/dali/utc-Dali-CameraActor.cpp

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <dali/public-api/dali-core.h>
  19
  20 #include <dali/devel-api/actors/actor-devel.h>
  21 #include <dali/devel-api/actors/camera-actor-devel.h>
  22 #include <stdlib.h>
  23
  24 #include <cmath>
  25 #include <iostream>
  26
  27 #include "dali-test-suite-utils/dali-test-suite-utils.h"
  28
  29 using namespace Dali;
  30
  31 void camera_actor_test_startup(void)
  32 {
  33   test_return_value = TET_UNDEF;
  34 }
  35
  36 void camera_actor_test_cleanup(void)
  37 {
  38   test_return_value = TET_PASS;
  39 }
  40
  41 namespace
  42 {
  43 const float FLOAT_EPSILON            = 0.001f;
  44 const float TEST_ASPECT_RATIO        = 0.123f;
  45 const float TEST_FIELD_OF_VIEW       = Radian(Degree(40.0f));
  46 const float TEST_NEAR_PLANE_DISTANCE = 0.23f;
  47 const float TEST_FAR_PLANE_DISTANCE  = 0.973f;
  48
  49 const std::string SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME("uLightCameraProjectionMatrix");
  50 const std::string SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME("uLightCameraViewMatrix");
  51 const char* const RENDER_SHADOW_VERTEX_SOURCE =
  52   " uniform mediump mat4 uLightCameraProjectionMatrix;\n"
  53   " uniform mediump mat4 uLightCameraViewMatrix;\n"
  54   "\n"
  55   "void main()\n"
  56   "{\n"
  57   "  gl_Position = uProjection * uModelView * vec4(aPosition,1.0);\n"
  58   "  vec4 textureCoords = uLightCameraProjectionMatrix * uLightCameraViewMatrix * uModelMatrix  * vec4(aPosition,1.0);\n"
  59   "  vTexCoord = 0.5 + 0.5 * (textureCoords.xy/textureCoords.w);\n"
  60   "}\n";
  61
  62 const char* const RENDER_SHADOW_FRAGMENT_SOURCE =
  63   "uniform lowp vec4 uShadowColor;\n"
  64   "void main()\n"
  65   "{\n"
  66   "  lowp float alpha;\n"
  67   "  alpha = texture2D(sTexture, vec2(vTexCoord.x, vTexCoord.y)).a;\n"
  68   "  gl_FragColor = vec4(uShadowColor.rgb, uShadowColor.a * alpha);\n"
  69   "}\n";
  70
  71 struct PropertyDetails
  72 {
  73   std::string     name;            ///< The name of the property.
  74   Property::Type  type;            ///< The property type.
  75   bool            writable;        ///< Whether the property is writable
  76   bool            animatable;      ///< Whether the property is animatable.
  77   bool            constraintInput; ///< Whether the property can be used as an input to a constraint.
  78   Property::Index enumIndex;       ///< Used to check the index is correct within a debug build.
  79 };
  80
  81 } // Anonymous namespace
  82
  83 int UtcDaliCameraActorConstructorP(void)
  84 {
  85   TestApplication application;
  86   tet_infoline("Testing Dali::CameraActor::CameraActor()");
  87
  88   CameraActor actor;
  89
  90   DALI_TEST_CHECK(!actor);
  91   END_TEST;
  92 }
  93
  94 // Note: No negative test for UtcDaliCameraActorConstructor.
  95
  96 int UtcDaliCameraActorDestructorP(void)
  97 {
  98   TestApplication application;
  99   tet_infoline("Testing Dali::~CameraActor (P)");
 100   CameraActor* actor = new CameraActor();
 101   delete actor;
 102   actor = NULL;
 103
 104   DALI_TEST_CHECK(true);
 105   END_TEST;
 106 }
 107
 108 // Note: No negative test for UtcDaliCameraActorDestructor.
 109
 110 int UtcDaliCameraActorCopyConstructorP(void)
 111 {
 112   TestApplication application;
 113   tet_infoline("Testing Dali::CameraActor Copy Constructor (P)");
 114   CameraActor actor = CameraActor::New();
 115
 116   CameraActor copyActor(actor);
 117
 118   DALI_TEST_CHECK(copyActor);
 119   DALI_TEST_CHECK(copyActor == actor);
 120
 121   END_TEST;
 122 }
 123
 124 int UtcDaliCameraActorCopyConstructorN(void)
 125 {
 126   TestApplication application;
 127   tet_infoline("Testing Dali::CameraActor Copy Constructor (N)");
 128   CameraActor actor;
 129
 130   CameraActor copyActor(actor);
 131
 132   DALI_TEST_CHECK(!copyActor);
 133
 134   END_TEST;
 135 }
 136
 137 int UtcDaliCameraActorAssignmentOperatorP(void)
 138 {
 139   TestApplication application;
 140   tet_infoline("Testing Dali::CameraActor Assignment Operator (P)");
 141   const CameraActor actor = CameraActor::New();
 142
 143   CameraActor copyActor = actor;
 144
 145   DALI_TEST_CHECK(copyActor);
 146   DALI_TEST_CHECK(copyActor == actor);
 147
 148   END_TEST;
 149 }
 150
 151 int UtcDaliCameraActorAssignmentOperatorN(void)
 152 {
 153   TestApplication application;
 154   tet_infoline("Testing Dali::CameraActor = (N)");
 155   CameraActor actor;
 156
 157   CameraActor copyActor = actor;
 158
 159   DALI_TEST_CHECK(!copyActor);
 160
 161   END_TEST;
 162 }
 163
 164 int UtcDaliCameraActorMoveConstructor(void)
 165 {
 166   TestApplication application;
 167
 168   CameraActor actor = CameraActor::New();
 169   DALI_TEST_CHECK(actor);
 170
 171   int id = actor.GetProperty<int>(Actor::Property::ID);
 172
 173   CameraActor moved = std::move(actor);
 174   DALI_TEST_CHECK(moved);
 175   DALI_TEST_EQUALS(id, moved.GetProperty<int>(Actor::Property::ID), TEST_LOCATION);
 176   DALI_TEST_CHECK(!actor);
 177
 178   END_TEST;
 179 }
 180
 181 int UtcDaliCameraActorMoveAssignment(void)
 182 {
 183   TestApplication application;
 184
 185   CameraActor actor = CameraActor::New();
 186   DALI_TEST_CHECK(actor);
 187
 188   int id = actor.GetProperty<int>(Actor::Property::ID);
 189
 190   CameraActor moved;
 191   moved = std::move(actor);
 192   DALI_TEST_CHECK(moved);
 193   DALI_TEST_EQUALS(id, moved.GetProperty<int>(Actor::Property::ID), TEST_LOCATION);
 194   DALI_TEST_CHECK(!actor);
 195
 196   END_TEST;
 197 }
 198
 199 int UtcDaliCameraActorNewP(void)
 200 {
 201   TestApplication application;
 202   tet_infoline("Testing Dali::CameraActor::New (P)");
 203
 204   CameraActor actor = CameraActor::New();
 205
 206   DALI_TEST_CHECK(actor);
 207
 208   actor.Reset();
 209
 210   DALI_TEST_CHECK(!actor);
 211   END_TEST;
 212 }
 213
 214 int UtcDaliCameraActorNewDefaultPerspectiveProjection(void)
 215 {
 216   TestApplication application;
 217   tet_infoline("Test the perspective projection of a camera actor is set appropriately when not passing in a size");
 218
 219   CameraActor actor = CameraActor::New();
 220   DALI_TEST_CHECK(actor);
 221
 222   // All the properties should still be the default values
 223   // Defaults taken from scene-graph-camera.cpp
 224   DALI_TEST_EQUALS(480.0f / 800.0f, actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 225   DALI_TEST_EQUALS(45.0f * (Math::PI / 180.0f), actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 226   DALI_TEST_EQUALS(800.0f, actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 227   DALI_TEST_EQUALS(3.0f * 800.0f, actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 228   DALI_TEST_EQUALS(400.0f, actor.GetProperty(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 229   DALI_TEST_EQUALS(0.0f, actor.GetProperty(Actor::Property::POSITION_Z).Get<float>(), TEST_LOCATION);
 230   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
 231
 232   // Add it to the stage, then the values should be updated to reflect a 480.0f by 800.0f scene (default stage size)
 233   application.GetScene().Add(actor);
 234
 235   DALI_TEST_EQUALS(0.6f, actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 236   DALI_TEST_EQUALS(0.489957f, actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 237   DALI_TEST_EQUALS(800.0f, actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 238   DALI_TEST_EQUALS(4895.0f, actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 239   DALI_TEST_EQUALS(400.0f, actor.GetProperty(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 240   DALI_TEST_EQUALS(1600.0f, actor.GetProperty(Actor::Property::POSITION_Z).Get<float>(), TEST_LOCATION);
 241   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
 242
 243   // Ensure the values stay the same after update/render
 244   application.SendNotification();
 245   application.Render();
 246
 247   DALI_TEST_EQUALS(0.6f, actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 248   DALI_TEST_EQUALS(0.489957f, actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 249   DALI_TEST_EQUALS(800.0f, actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 250   DALI_TEST_EQUALS(4895.0f, actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 251   DALI_TEST_EQUALS(400.0f, actor.GetProperty(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 252   DALI_TEST_EQUALS(1600.0f, actor.GetProperty(Actor::Property::POSITION_Z).Get<float>(), TEST_LOCATION);
 253   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
 254
 255   END_TEST;
 256 }
 257
 258 // Note: No negative test for UtcDaliCameraActorNew.
 259
 260 int UtcDaliCameraActorDownCastP(void)
 261 {
 262   TestApplication application;
 263   tet_infoline("Testing Dali::CameraActor::DownCast (P)");
 264
 265   CameraActor camera  = CameraActor::New();
 266   Actor       anActor = Actor::New();
 267   anActor.Add(camera);
 268
 269   Actor       child       = anActor.GetChildAt(0);
 270   CameraActor cameraActor = CameraActor::DownCast(child);
 271   DALI_TEST_CHECK(cameraActor);
 272
 273   cameraActor.Reset();
 274   DALI_TEST_CHECK(!cameraActor);
 275
 276   cameraActor = DownCast<CameraActor>(child);
 277   DALI_TEST_CHECK(cameraActor);
 278   END_TEST;
 279 }
 280
 281 int UtcDaliCameraActorDownCastN(void)
 282 {
 283   TestApplication application;
 284   tet_infoline("Testing Dali::CameraActor::DownCast (N)");
 285
 286   Actor actor1  = Actor::New();
 287   Actor anActor = Actor::New();
 288   anActor.Add(actor1);
 289
 290   Actor       child       = anActor.GetChildAt(0);
 291   CameraActor cameraActor = CameraActor::DownCast(child);
 292   DALI_TEST_CHECK(!cameraActor);
 293
 294   Actor unInitialzedActor;
 295   cameraActor = CameraActor::DownCast(unInitialzedActor);
 296   DALI_TEST_CHECK(!cameraActor);
 297
 298   cameraActor = DownCast<CameraActor>(unInitialzedActor);
 299   DALI_TEST_CHECK(!cameraActor);
 300   END_TEST;
 301 }
 302
 303 // Note: SetType and GetType are tested within the same test cases.
 304
 305 int UtcDaliCameraActorSetGetTypeP(void)
 306 {
 307   TestApplication application;
 308   tet_infoline("Testing Dali::CameraActor GetType (P)");
 309
 310   CameraActor actor = CameraActor::New();
 311   DALI_TEST_EQUALS(actor.GetType(), Dali::Camera::FREE_LOOK, TEST_LOCATION);
 312
 313   actor.SetType(Dali::Camera::LOOK_AT_TARGET);
 314   DALI_TEST_EQUALS(actor.GetType(), Dali::Camera::LOOK_AT_TARGET, TEST_LOCATION);
 315
 316   Dali::Camera::Type cameraType        = actor.GetProperty<Dali::Camera::Type>(CameraActor::Property::TYPE);
 317   Dali::Camera::Type currentCameraType = actor.GetCurrentProperty<Dali::Camera::Type>(CameraActor::Property::TYPE);
 318   DALI_TEST_EQUALS(Camera::LOOK_AT_TARGET, cameraType, TEST_LOCATION);
 319   DALI_TEST_EQUALS(Camera::LOOK_AT_TARGET, currentCameraType, TEST_LOCATION);
 320   END_TEST;
 321 }
 322
 323 int UtcDaliCameraActorSetGetTypeN(void)
 324 {
 325   TestApplication application;
 326   tet_infoline("Testing Dali::CameraActor GetType (N)");
 327
 328   CameraActor actor;
 329
 330   Dali::Camera::Type cameraType = Dali::Camera::FREE_LOOK;
 331   try
 332   {
 333     cameraType = actor.GetType();
 334   }
 335   catch(Dali::DaliException& e)
 336   {
 337     DALI_TEST_PRINT_ASSERT(e);
 338     DALI_TEST_ASSERT(e, "camera", TEST_LOCATION);
 339   }
 340
 341   const CameraActor aConstActor;
 342
 343   try
 344   {
 345     cameraType = aConstActor.GetType();
 346   }
 347   catch(Dali::DaliException& e)
 348   {
 349     DALI_TEST_PRINT_ASSERT(e);
 350     DALI_TEST_ASSERT(e, "camera", TEST_LOCATION);
 351   }
 352
 353   DALI_TEST_EQUALS(cameraType, Dali::Camera::FREE_LOOK, TEST_LOCATION);
 354   END_TEST;
 355 }
 356
 357 int UtcDaliCameraActorSetFieldOfViewP(void)
 358 {
 359   TestApplication application;
 360   tet_infoline("Testing Dali::CameraActor Set Field of view (P)");
 361
 362   CameraActor defaultCamera      = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
 363   const float defaultFieldOfView = defaultCamera.GetFieldOfView();
 364
 365   CameraActor actor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
 366   DALI_TEST_EQUALS(actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION);
 367
 368   float fieldOfView = Math::PI / 3.0f;
 369   actor.SetFieldOfView(fieldOfView);
 370   DALI_TEST_EQUALS(actor.GetFieldOfView(), fieldOfView, TEST_LOCATION);
 371
 372   float value;
 373   actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
 374   DALI_TEST_EQUALS(fieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
 375   END_TEST;
 376 }
 377
 378 int UtcDaliCameraActorSetFieldOfViewN(void)
 379 {
 380   TestApplication application;
 381   tet_infoline("Testing Dali::CameraActor Set Field of view (N)");
 382
 383   CameraActor defaultCamera      = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
 384   const float defaultFieldOfView = defaultCamera.GetFieldOfView();
 385
 386   CameraActor actor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
 387   DALI_TEST_EQUALS(actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION);
 388
 389   float fieldOfView = Math::PI / 3.0f;
 390   actor.SetFieldOfView(fieldOfView);
 391   DALI_TEST_EQUALS(actor.GetFieldOfView(), fieldOfView, TEST_LOCATION);
 392
 393   float value;
 394   actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
 395   DALI_TEST_EQUALS(fieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
 396   END_TEST;
 397 }
 398
 399 int UtcDaliCameraActorGetFieldOfViewP(void)
 400 {
 401   TestApplication application;
 402   tet_infoline("Testing Dali::CameraActor Get Field of view (P)");
 403   const Vector2 size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
 404
 405   CameraActor defaultCamera = CameraActor::New(size);
 406
 407   const float cameraZ             = 2.0f * std::max(size.width, size.height);
 408   const float expectedFieldOfView = 2.0f * std::atan(size.height * 0.5f / cameraZ);
 409
 410   CameraActor actor = CameraActor::New(size);
 411   DALI_TEST_EQUALS(actor.GetFieldOfView(), expectedFieldOfView, TEST_LOCATION);
 412
 413   float value;
 414   actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
 415   DALI_TEST_EQUALS(expectedFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
 416   END_TEST;
 417 }
 418
 419 int UtcDaliCameraActorGetFieldOfViewN(void)
 420 {
 421   TestApplication application;
 422   tet_infoline("Testing Dali::CameraActor Get Field of view (N)");
 423
 424   CameraActor defaultCamera = CameraActor::New();
 425
 426   bool asserted = true;
 427   try
 428   {
 429     defaultCamera.GetFieldOfView();
 430   }
 431   catch(Dali::DaliException& e)
 432   {
 433     DALI_TEST_PRINT_ASSERT(e);
 434     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 435     asserted = true;
 436   }
 437   DALI_TEST_CHECK(asserted);
 438
 439   END_TEST;
 440 }
 441
 442 int UtcDaliCameraActorSetAspectRatioP(void)
 443 {
 444   TestApplication application;
 445   tet_infoline("Testing Dali::CameraActor Set Aspect Ratio (P)");
 446
 447   CameraActor actor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
 448   DALI_TEST_EQUALS(actor.GetAspectRatio(), static_cast<float>(TestApplication::DEFAULT_SURFACE_WIDTH) / static_cast<float>(TestApplication::DEFAULT_SURFACE_HEIGHT), TEST_LOCATION);
 449
 450   // Set an initial value to confirm a further set changes it.
 451   float aspect = 4.0f / 3.0f;
 452   actor.SetAspectRatio(aspect);
 453   DALI_TEST_EQUALS(actor.GetAspectRatio(), aspect, TEST_LOCATION);
 454
 455   aspect = 16.0f / 9.0f;
 456   actor.SetAspectRatio(aspect);
 457   DALI_TEST_EQUALS(actor.GetAspectRatio(), aspect, TEST_LOCATION);
 458
 459   END_TEST;
 460 }
 461
 462 int UtcDaliCameraActorSetAspectRatioN(void)
 463 {
 464   TestApplication application;
 465   tet_infoline("Testing Dali::CameraActor Set Aspect Ratio (N)");
 466
 467   CameraActor actor;
 468
 469   bool asserted = true;
 470   try
 471   {
 472     actor.SetAspectRatio(16.0f / 9.0f);
 473   }
 474   catch(Dali::DaliException& e)
 475   {
 476     DALI_TEST_PRINT_ASSERT(e);
 477     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 478     asserted = true;
 479   }
 480   DALI_TEST_CHECK(asserted);
 481
 482   END_TEST;
 483 }
 484
 485 int UtcDaliCameraActorGetAspectRatioP(void)
 486 {
 487   TestApplication application;
 488   tet_infoline("Testing Dali::CameraActor Get Aspect Ratio");
 489
 490   CameraActor actor         = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
 491   float       defaultAspect = static_cast<float>(TestApplication::DEFAULT_SURFACE_WIDTH) / static_cast<float>(TestApplication::DEFAULT_SURFACE_HEIGHT);
 492
 493   DALI_TEST_EQUALS(actor.GetAspectRatio(), defaultAspect, TEST_LOCATION);
 494
 495   float value = 0.0f;
 496   actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
 497   DALI_TEST_EQUALS(defaultAspect, value, FLOAT_EPSILON, TEST_LOCATION);
 498
 499   END_TEST;
 500 }
 501
 502 int UtcDaliCameraActorGetAspectRatioN(void)
 503 {
 504   TestApplication application;
 505   tet_infoline("Testing Dali::CameraActor Get Aspect Ratio (N)");
 506
 507   CameraActor actor;
 508
 509   bool asserted = true;
 510   try
 511   {
 512     actor.GetAspectRatio();
 513   }
 514   catch(Dali::DaliException& e)
 515   {
 516     DALI_TEST_PRINT_ASSERT(e);
 517     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 518     asserted = true;
 519   }
 520
 521   DALI_TEST_CHECK(asserted);
 522
 523   END_TEST;
 524 }
 525
 526 int UtcDaliCameraActorSetNearClippingPlaneP(void)
 527 {
 528   TestApplication application;
 529   tet_infoline("Testing Dali::CameraActor Set Near clipping plane (P)");
 530
 531   CameraActor actor = CameraActor::New();
 532
 533   // Set a value so we are not relying on a particular default for this test case.
 534   actor.SetNearClippingPlane(200.0f);
 535   DALI_TEST_EQUALS(actor.GetNearClippingPlane(), 200.0f, TEST_LOCATION);
 536
 537   actor.SetNearClippingPlane(400.0f);
 538   DALI_TEST_EQUALS(actor.GetNearClippingPlane(), 400.0f, TEST_LOCATION);
 539
 540   // Check setting the property.
 541   actor.SetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE, Property::Value(300.0f));
 542   DALI_TEST_EQUALS(actor.GetNearClippingPlane(), 300.0f, FLOAT_EPSILON, TEST_LOCATION);
 543   END_TEST;
 544 }
 545
 546 int UtcDaliCameraActorSetNearClippingPlaneN(void)
 547 {
 548   TestApplication application;
 549   tet_infoline("Testing Dali::CameraActor Set Near clipping plane (N)");
 550
 551   CameraActor actor;
 552
 553   bool asserted = true;
 554   try
 555   {
 556     actor.SetNearClippingPlane(200.0f);
 557   }
 558   catch(Dali::DaliException& e)
 559   {
 560     DALI_TEST_PRINT_ASSERT(e);
 561     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 562     asserted = true;
 563   }
 564
 565   DALI_TEST_CHECK(asserted);
 566
 567   END_TEST;
 568 }
 569
 570 int UtcDaliCameraActorGetNearClippingPlaneP(void)
 571 {
 572   TestApplication application;
 573   tet_infoline("Testing Dali::CameraActor Get Near clipping plane (P)");
 574
 575   // Check the default value.
 576   CameraActor actor        = CameraActor::New();
 577   float       defaultValue = 800.0f;
 578   DALI_TEST_EQUALS(actor.GetNearClippingPlane(), defaultValue, TEST_LOCATION);
 579
 580   // Check getting the property.
 581   float value;
 582   actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
 583   DALI_TEST_EQUALS(defaultValue, value, FLOAT_EPSILON, TEST_LOCATION);
 584   END_TEST;
 585 }
 586
 587 int UtcDaliCameraActorGetNearClippingPlaneN(void)
 588 {
 589   TestApplication application;
 590   tet_infoline("Testing Dali::CameraActor Get Near clipping plane (N)");
 591
 592   CameraActor actor;
 593   bool        asserted = true;
 594   try
 595   {
 596     actor.GetNearClippingPlane();
 597   }
 598   catch(Dali::DaliException& e)
 599   {
 600     DALI_TEST_PRINT_ASSERT(e);
 601     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 602     asserted = true;
 603   }
 604
 605   DALI_TEST_CHECK(asserted);
 606
 607   END_TEST;
 608 }
 609
 610 int UtcDaliCameraActorSetFarClippingPlaneP(void)
 611 {
 612   TestApplication application;
 613   tet_infoline("Testing Dali::CameraActor Set Far clipping plane (P)");
 614
 615   CameraActor actor = CameraActor::New();
 616
 617   // Set a value so we are not relying on a particular default for this test case.
 618   actor.SetFarClippingPlane(2000.0f);
 619   DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 2000.0f, TEST_LOCATION);
 620
 621   actor.SetFarClippingPlane(4000.0f);
 622   DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 4000.0f, TEST_LOCATION);
 623
 624   // Check setting the property.
 625   actor.SetProperty(CameraActor::Property::FAR_PLANE_DISTANCE, 2000.0f);
 626   DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 2000.0f, FLOAT_EPSILON, TEST_LOCATION);
 627   END_TEST;
 628 }
 629
 630 int UtcDaliCameraActorSetFarClippingPlaneN(void)
 631 {
 632   TestApplication application;
 633   tet_infoline("Testing Dali::CameraActor Set Far clipping plane (N)");
 634
 635   CameraActor actor;
 636
 637   bool asserted = true;
 638   try
 639   {
 640     actor.SetFarClippingPlane(2000.0f);
 641   }
 642   catch(Dali::DaliException& e)
 643   {
 644     DALI_TEST_PRINT_ASSERT(e);
 645     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 646     asserted = true;
 647   }
 648
 649   DALI_TEST_CHECK(asserted);
 650
 651   END_TEST;
 652 }
 653
 654 int UtcDaliCameraActorGetFarClippingPlaneP(void)
 655 {
 656   TestApplication application;
 657   tet_infoline("Testing Dali::CameraActor Get Far clipping plane (P)");
 658
 659   CameraActor actor        = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
 660   float       defaultValue = 800.0f + (0xFFFF >> 4);
 661   DALI_TEST_EQUALS(actor.GetFarClippingPlane(), defaultValue, TEST_LOCATION);
 662
 663   // Check getting the property.
 664   float value;
 665   actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
 666   DALI_TEST_EQUALS(defaultValue, value, FLOAT_EPSILON, TEST_LOCATION);
 667   END_TEST;
 668 }
 669
 670 int UtcDaliCameraActorGetFarClippingPlaneN(void)
 671 {
 672   TestApplication application;
 673   tet_infoline("Testing Dali::CameraActor Get Far clipping plane (N)");
 674
 675   CameraActor actor;
 676
 677   bool asserted = true;
 678   try
 679   {
 680     actor.GetFarClippingPlane();
 681   }
 682   catch(Dali::DaliException& e)
 683   {
 684     DALI_TEST_PRINT_ASSERT(e);
 685     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 686     asserted = true;
 687   }
 688
 689   DALI_TEST_CHECK(asserted);
 690
 691   END_TEST;
 692 }
 693
 694 int UtcDaliCameraActorSetTargetPositionP(void)
 695 {
 696   TestApplication application;
 697   tet_infoline("Testing Dali::CameraActor Set Target Position (P)");
 698
 699   CameraActor actor = CameraActor::New();
 700
 701   Vector3 target1(10.0f, 20.0f, 30.0f);
 702   Vector3 target2(15.0f, 25.0f, 35.0f);
 703
 704   // Set a value so we are not relying on a particular default for this test case.
 705   actor.SetTargetPosition(target1);
 706   DALI_TEST_EQUALS(actor.GetTargetPosition(), target1, TEST_LOCATION);
 707
 708   actor.SetTargetPosition(target2);
 709   DALI_TEST_EQUALS(actor.GetTargetPosition(), target2, TEST_LOCATION);
 710
 711   // Check setting the property.
 712   actor.SetProperty(CameraActor::Property::TARGET_POSITION, target1);
 713   DALI_TEST_EQUALS(actor.GetTargetPosition(), target1, FLOAT_EPSILON, TEST_LOCATION);
 714   END_TEST;
 715 }
 716
 717 int UtcDaliCameraActorSetTargetPositionN(void)
 718 {
 719   TestApplication application;
 720   tet_infoline("Testing Dali::CameraActor Set Target Position (N)");
 721
 722   CameraActor actor;
 723
 724   bool asserted = true;
 725   try
 726   {
 727     actor.SetTargetPosition(Vector3(10.0f, 20.0f, 30.0f));
 728   }
 729   catch(Dali::DaliException& e)
 730   {
 731     DALI_TEST_PRINT_ASSERT(e);
 732     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 733     asserted = true;
 734   }
 735   DALI_TEST_CHECK(asserted);
 736
 737   END_TEST;
 738 }
 739
 740 int UtcDaliCameraActorGetTargetPositionP(void)
 741 {
 742   TestApplication application;
 743   tet_infoline("Testing Dali::CameraActor Get Target Position (P)");
 744
 745   CameraActor actor = CameraActor::New();
 746   Vector3     defaultValue(Vector3::ZERO);
 747   DALI_TEST_EQUALS(actor.GetTargetPosition(), defaultValue, TEST_LOCATION);
 748
 749   // Check getting the property.
 750   Vector3 value;
 751   actor.GetProperty(CameraActor::Property::TARGET_POSITION).Get(value);
 752   DALI_TEST_EQUALS(defaultValue, value, FLOAT_EPSILON, TEST_LOCATION);
 753   END_TEST;
 754 }
 755
 756 int UtcDaliCameraActorGetTargetPositionN(void)
 757 {
 758   TestApplication application;
 759   tet_infoline("Testing Dali::CameraActor Get Target Position (N)");
 760
 761   CameraActor actor;
 762
 763   bool asserted = true;
 764   try
 765   {
 766     actor.GetTargetPosition();
 767   }
 768   catch(Dali::DaliException& e)
 769   {
 770     DALI_TEST_PRINT_ASSERT(e);
 771     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 772     asserted = true;
 773   }
 774   DALI_TEST_CHECK(asserted);
 775
 776   END_TEST;
 777 }
 778
 779 int UtcDaliCameraActorSetInvertYAxisP(void)
 780 {
 781   TestApplication application;
 782   tet_infoline("Testing Dali::CameraActor Set InvertYAxis (P)");
 783
 784   CameraActor actor = CameraActor::New();
 785
 786   // Set a value so we are not relying on a particular default for this test case.
 787   actor.SetInvertYAxis(false);
 788   DALI_TEST_EQUALS(actor.GetInvertYAxis(), false, TEST_LOCATION);
 789
 790   actor.SetInvertYAxis(true);
 791   DALI_TEST_EQUALS(actor.GetInvertYAxis(), true, TEST_LOCATION);
 792
 793   actor.SetProperty(CameraActor::Property::INVERT_Y_AXIS, false);
 794   DALI_TEST_EQUALS(actor.GetInvertYAxis(), false, TEST_LOCATION);
 795   END_TEST;
 796 }
 797
 798 int UtcDaliCameraActorSetInvertYAxisN(void)
 799 {
 800   TestApplication application;
 801   tet_infoline("Testing Dali::CameraActor Set InvertYAxis (N)");
 802
 803   CameraActor actor;
 804
 805   bool asserted = true;
 806   try
 807   {
 808     actor.SetInvertYAxis(false);
 809   }
 810   catch(Dali::DaliException& e)
 811   {
 812     DALI_TEST_PRINT_ASSERT(e);
 813     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 814     asserted = true;
 815   }
 816   DALI_TEST_CHECK(asserted);
 817   END_TEST;
 818 }
 819
 820 int UtcDaliCameraActorGetInvertYAxisP(void)
 821 {
 822   TestApplication application;
 823   tet_infoline("Testing Dali::CameraActor Get InvertYAxis (P)");
 824
 825   // Check the default value.
 826   CameraActor actor = CameraActor::New();
 827   DALI_TEST_EQUALS(actor.GetInvertYAxis(), false, TEST_LOCATION);
 828
 829   // Check getting the property.
 830   bool bValue;
 831   actor.GetProperty(CameraActor::Property::INVERT_Y_AXIS).Get(bValue);
 832   DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
 833   END_TEST;
 834 }
 835
 836 int UtcDaliCameraActorGetInvertYAxisN(void)
 837 {
 838   TestApplication application;
 839   tet_infoline("Testing Dali::CameraActor Get InvertYAxis (N)");
 840
 841   CameraActor actor;
 842
 843   bool asserted = true;
 844   try
 845   {
 846     actor.GetInvertYAxis();
 847   }
 848   catch(Dali::DaliException& e)
 849   {
 850     DALI_TEST_PRINT_ASSERT(e);
 851     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
 852     asserted = true;
 853   }
 854   DALI_TEST_CHECK(asserted);
 855   END_TEST;
 856 }
 857
 858 int UtcDaliCameraActorSetGetOthographicSizeP(void)
 859 {
 860   TestApplication application;
 861   tet_infoline("Testing Dali::CameraActor Set Orthographic Size (P)");
 862
 863   CameraActor actor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
 864   actor.SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION);
 865
 866   // Get default orthographic size by inputed size
 867   DALI_TEST_EQUALS(actor.GetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE).Get<float>(), static_cast<float>(TestApplication::DEFAULT_SURFACE_HEIGHT) * 0.5f, TEST_LOCATION);
 868
 869   float value = 0.0f;
 870
 871   // Set an initial value to confirm a further set changes it.
 872   float size = 300.0f;
 873   actor.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, size);
 874
 875   value = 0.0f;
 876   DALI_TEST_CHECK(actor.GetProperty(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE).Get(value));
 877   DALI_TEST_EQUALS(value, size, TEST_LOCATION);
 878
 879   size = 1600.0f;
 880   actor.SetProperty(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, size);
 881
 882   value = 0.0f;
 883   DALI_TEST_CHECK(actor.GetProperty(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE).Get(value));
 884   DALI_TEST_EQUALS(value, size, TEST_LOCATION);
 885
 886   actor.SetProperty(DevelCameraActor::Property::PROJECTION_DIRECTION, DevelCameraActor::ProjectionDirection::HORIZONTAL);
 887
 888   size = 600.0f;
 889   actor.SetProperty(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, size);
 890
 891   value = 0.0f;
 892   DALI_TEST_CHECK(actor.GetProperty(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE).Get(value));
 893   DALI_TEST_EQUALS(value, size, TEST_LOCATION);
 894
 895   END_TEST;
 896 }
 897
 898 int UtcDaliCameraActorSetPerspectiveProjectionP(void)
 899 {
 900   TestApplication application;
 901   tet_infoline("Testing Dali::CameraActor::SetPerspectiveProjection (P)");
 902
 903   CameraActor actor = CameraActor::New();
 904   actor.SetPerspectiveProjection(Size(100.f, 150.f));
 905
 906   DALI_TEST_CHECK(actor);
 907
 908   float value;
 909   actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
 910   DALI_TEST_EQUALS(0.666666f, value, FLOAT_EPSILON, TEST_LOCATION);
 911   actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
 912   DALI_TEST_EQUALS(0.489957f, value, FLOAT_EPSILON, TEST_LOCATION);
 913   actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
 914   DALI_TEST_EQUALS(150.f, value, FLOAT_EPSILON, TEST_LOCATION);
 915   actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
 916   DALI_TEST_EQUALS(4245.f, value, FLOAT_EPSILON, TEST_LOCATION);
 917
 918   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
 919
 920   // Ensure these values persist after adding to the stage and an update/render pass
 921   application.GetScene().Add(actor);
 922   application.SendNotification();
 923   application.Render();
 924
 925   actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
 926   DALI_TEST_EQUALS(0.666666f, value, FLOAT_EPSILON, TEST_LOCATION);
 927   actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
 928   DALI_TEST_EQUALS(0.489957f, value, FLOAT_EPSILON, TEST_LOCATION);
 929   actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
 930   DALI_TEST_EQUALS(150.f, value, FLOAT_EPSILON, TEST_LOCATION);
 931   actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
 932   DALI_TEST_EQUALS(4245.f, value, FLOAT_EPSILON, TEST_LOCATION);
 933
 934   // Call method with a ZERO size, this should reset the perspective projection using the size of the scene we've been added to
 935   actor.SetPerspectiveProjection(Vector2::ZERO);
 936
 937   DALI_TEST_EQUALS(0.6f, actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 938   DALI_TEST_EQUALS(0.489957f, actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 939   DALI_TEST_EQUALS(800.0f, actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 940   DALI_TEST_EQUALS(4895.0f, actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
 941   DALI_TEST_EQUALS(1600.0f, actor.GetProperty(Actor::Property::POSITION_Z).Get<float>(), TEST_LOCATION);
 942   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
 943
 944   END_TEST;
 945 }
 946
 947 int UtcDaliCameraActorSetPerspectiveProjectionN(void)
 948 {
 949   TestApplication application;
 950   tet_infoline("Testing Dali::CameraActor::SetPerspectiveProjection (N)");
 951
 952   CameraActor actor = CameraActor::New();
 953
 954   // Check that setting perspective projection without a size does not do anything.
 955   actor.SetPerspectiveProjection(Size::ZERO);
 956
 957   // So the default values should be the same as defined in CameraActor
 958   float nearClippingPlane = 800.0f;
 959   float farClippingPlane  = nearClippingPlane + 2.0f * nearClippingPlane;
 960
 961   DALI_TEST_EQUALS(nearClippingPlane, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
 962   DALI_TEST_EQUALS(farClippingPlane, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
 963   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
 964
 965   END_TEST;
 966 }
 967
 968 int UtcDaliCameraActorSetOrthographicProjectionP1(void)
 969 {
 970   TestApplication application;
 971   tet_infoline("Testing Dali::CameraActor::SetOrthographicProjection (P,1)");
 972
 973   CameraActor actor = CameraActor::New(Size(1080.0f, 1920.0f));
 974   DALI_TEST_CHECK(actor);
 975
 976   application.GetScene().Add(actor);
 977
 978   actor.SetOrthographicProjection(Size(1080.0f, 1920.0f));
 979
 980   application.SendNotification();
 981   application.Render(0);
 982   application.Render();
 983   application.SendNotification();
 984
 985   float defaultAspectRatio;
 986   float defaultNearPlaneDistance;
 987   float defaultFarPlaneDistance;
 988   actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(defaultAspectRatio);
 989   actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(defaultNearPlaneDistance);
 990   actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(defaultFarPlaneDistance);
 991   Vector3 defaultPos = actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION);
 992
 993   auto TestOrthographicPlaneDistance = [&](float width, float height, float expectOrthographicSize) {
 994     actor.SetOrthographicProjection(Size(width, height));
 995
 996     DALI_TEST_EQUALS(expectOrthographicSize, actor.GetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE).Get<float>(), TEST_LOCATION);
 997
 998     application.SendNotification();
 999     application.Render(0);
1000     application.Render();
1001     application.SendNotification();
1002
1003     float value;
1004     actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
1005     DALI_TEST_EQUALS(defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION);
1006     actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
1007     DALI_TEST_EQUALS(defaultNearPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION);
1008     actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
1009     DALI_TEST_EQUALS(defaultFarPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION);
1010
1011     actor.GetProperty(CameraActor::Property::LEFT_PLANE_DISTANCE).Get(value);
1012     DALI_TEST_EQUALS(-540.0f, value, FLOAT_EPSILON, TEST_LOCATION);
1013     actor.GetProperty(CameraActor::Property::RIGHT_PLANE_DISTANCE).Get(value);
1014     DALI_TEST_EQUALS(540.0f, value, FLOAT_EPSILON, TEST_LOCATION);
1015     actor.GetProperty(CameraActor::Property::TOP_PLANE_DISTANCE).Get(value);
1016     DALI_TEST_EQUALS(960.0f, value, FLOAT_EPSILON, TEST_LOCATION);
1017     actor.GetProperty(CameraActor::Property::BOTTOM_PLANE_DISTANCE).Get(value);
1018     DALI_TEST_EQUALS(-960.0f, value, FLOAT_EPSILON, TEST_LOCATION);
1019
1020     Vector3 pos = actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION);
1021     DALI_TEST_EQUALS(defaultPos.z, pos.z, 0.001f, TEST_LOCATION);
1022
1023     DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
1024   };
1025
1026   TestOrthographicPlaneDistance(1080.0f, 1920.0f, 960.0f);
1027   // Change projection direction
1028   actor.SetProperty(DevelCameraActor::Property::PROJECTION_DIRECTION, DevelCameraActor::ProjectionDirection::HORIZONTAL);
1029   TestOrthographicPlaneDistance(1080.0f, 1920.0f, 540.0f);
1030   END_TEST;
1031 }
1032
1033 int UtcDaliCameraActorSetOrthographicProjectionN(void)
1034 {
1035   TestApplication application;
1036   tet_infoline("Testing Dali::CameraActor::SetOrthographicProjection (N)");
1037
1038   CameraActor actor;
1039   bool        asserted = true;
1040   try
1041   {
1042     actor.GetProjectionMode();
1043   }
1044   catch(Dali::DaliException& e)
1045   {
1046     DALI_TEST_PRINT_ASSERT(e);
1047     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
1048     asserted = true;
1049   }
1050   DALI_TEST_CHECK(asserted);
1051   END_TEST;
1052 }
1053
1054 int UtcDaliCameraActorSetProjectionModeP(void)
1055 {
1056   TestApplication application;
1057   tet_infoline("Testing Dali::CameraActor::SetProjectionModeP (P)");
1058
1059   CameraActor actor = CameraActor::New();
1060
1061   // Check that changing the projection mode alone does not alter other presets.
1062   actor.SetNearClippingPlane(200.0f);
1063   actor.SetFarClippingPlane(400.0f);
1064
1065   actor.SetProjectionMode(Dali::Camera::PERSPECTIVE_PROJECTION);
1066
1067   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
1068   DALI_TEST_EQUALS(actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION);
1069   DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION);
1070
1071   actor.SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION);
1072
1073   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
1074   DALI_TEST_EQUALS(actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION);
1075   DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION);
1076
1077   // Check setting the property.
1078   Property::Value setValue = Dali::Camera::PERSPECTIVE_PROJECTION;
1079   actor.SetProperty(CameraActor::Property::PROJECTION_MODE, setValue);
1080   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
1081   END_TEST;
1082 }
1083
1084 int UtcDaliCameraActorSetProjectionModeN(void)
1085 {
1086   TestApplication application;
1087   tet_infoline("Testing Dali::CameraActor::SetProjectionModeP (N)");
1088
1089   CameraActor actor;
1090
1091   bool asserted = true;
1092   try
1093   {
1094     actor.SetProjectionMode(Dali::Camera::PERSPECTIVE_PROJECTION);
1095   }
1096   catch(Dali::DaliException& e)
1097   {
1098     DALI_TEST_PRINT_ASSERT(e);
1099     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
1100     asserted = true;
1101   }
1102   DALI_TEST_CHECK(asserted);
1103   END_TEST;
1104 }
1105
1106 int UtcDaliCameraActorGetProjectionModeP(void)
1107 {
1108   TestApplication application;
1109   tet_infoline("Testing Dali::CameraActor::GetPerspectiveProjection (P)");
1110
1111   CameraActor actor = CameraActor::New();
1112
1113   actor.SetOrthographicProjection(Size::ONE);
1114   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
1115
1116   actor.SetPerspectiveProjection(Size(100.f, 150.f));
1117   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
1118
1119   // Check getting the property.
1120   Dali::Camera::ProjectionMode projectionMode = actor.GetProperty<Dali::Camera::ProjectionMode>(CameraActor::Property::PROJECTION_MODE);
1121   DALI_TEST_EQUALS(projectionMode, Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
1122   END_TEST;
1123 }
1124
1125 int UtcDaliCameraActorGetProjectionModeN(void)
1126 {
1127   TestApplication application;
1128   tet_infoline("Testing Dali::CameraActor::GetProjectionMode (N)");
1129
1130   CameraActor actor;
1131
1132   bool asserted = true;
1133   try
1134   {
1135     actor.GetProjectionMode();
1136   }
1137   catch(Dali::DaliException& e)
1138   {
1139     DALI_TEST_PRINT_ASSERT(e);
1140     DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
1141     asserted = true;
1142   }
1143   DALI_TEST_CHECK(asserted);
1144   END_TEST;
1145 }
1146
1147 int UtcDaliCameraActorSetCameraOffScene(void)
1148 {
1149   TestApplication application;
1150   tet_infoline("Testing Dali::CameraActor::SetCamera()");
1151
1152   CameraActor actor = CameraActor::New();
1153
1154   actor.SetType(Camera::FREE_LOOK);
1155   actor.SetFieldOfView(TEST_FIELD_OF_VIEW);
1156   actor.SetAspectRatio(TEST_ASPECT_RATIO);
1157   actor.SetNearClippingPlane(TEST_NEAR_PLANE_DISTANCE);
1158   actor.SetFarClippingPlane(TEST_FAR_PLANE_DISTANCE);
1159   actor.SetProjectionMode(Camera::PERSPECTIVE_PROJECTION);
1160
1161   actor.SetInvertYAxis(false);
1162
1163   DALI_TEST_EQUALS(TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION); //change to machine epsilon
1164   DALI_TEST_EQUALS(TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION);
1165   DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
1166   DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
1167   DALI_TEST_EQUALS(Camera::PERSPECTIVE_PROJECTION, actor.GetProjectionMode(), TEST_LOCATION);
1168   DALI_TEST_EQUALS(false, actor.GetInvertYAxis(), TEST_LOCATION);
1169
1170   float       value;
1171   std::string sValue;
1172   actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
1173   DALI_TEST_EQUALS(TEST_ASPECT_RATIO, value, FLOAT_EPSILON, TEST_LOCATION);
1174   actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
1175   DALI_TEST_EQUALS(TEST_FIELD_OF_VIEW, value, FLOAT_EPSILON, TEST_LOCATION);
1176   actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
1177   DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION);
1178   actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
1179   DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION);
1180
1181   Dali::Camera::ProjectionMode projectionMode = actor.GetProperty<Dali::Camera::ProjectionMode>(CameraActor::Property::PROJECTION_MODE);
1182   DALI_TEST_EQUALS(Dali::Camera::PERSPECTIVE_PROJECTION, projectionMode, TEST_LOCATION);
1183   bool bValue;
1184   actor.GetProperty(CameraActor::Property::INVERT_Y_AXIS).Get(bValue);
1185   DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
1186   END_TEST;
1187 }
1188
1189 int UtcDaliCameraActorSetCameraOnScene(void)
1190 {
1191   TestApplication application;
1192   tet_infoline("Testing Dali::CameraActor::SetCamera()");
1193
1194   CameraActor actor = CameraActor::New();
1195   application.GetScene().Add(actor);
1196   application.Render(0);
1197   application.SendNotification();
1198
1199   actor.SetType(Camera::LOOK_AT_TARGET);
1200   actor.SetFieldOfView(TEST_FIELD_OF_VIEW);
1201   actor.SetAspectRatio(TEST_ASPECT_RATIO);
1202   actor.SetNearClippingPlane(TEST_NEAR_PLANE_DISTANCE);
1203   actor.SetFarClippingPlane(TEST_FAR_PLANE_DISTANCE);
1204   actor.SetInvertYAxis(false);
1205
1206   DALI_TEST_EQUALS(false, actor.GetInvertYAxis(), TEST_LOCATION);
1207
1208   // Will need 2 frames to ensure both buffers are set to same values:
1209   application.Render();
1210   application.SendNotification();
1211   application.Render();
1212   application.SendNotification();
1213
1214   DALI_TEST_EQUALS(TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION);
1215   DALI_TEST_EQUALS(TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION);
1216   DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
1217   DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
1218   DALI_TEST_EQUALS(false, actor.GetInvertYAxis(), TEST_LOCATION);
1219
1220   Dali::Camera::Type cameraType = actor.GetProperty<Dali::Camera::Type>(CameraActor::Property::TYPE);
1221   DALI_TEST_EQUALS(cameraType, Camera::LOOK_AT_TARGET, TEST_LOCATION);
1222
1223   float value;
1224   actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
1225   DALI_TEST_EQUALS(TEST_ASPECT_RATIO, value, FLOAT_EPSILON, TEST_LOCATION);
1226   actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
1227   DALI_TEST_EQUALS(TEST_FIELD_OF_VIEW, value, FLOAT_EPSILON, TEST_LOCATION);
1228   actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
1229   DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION);
1230   actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
1231   DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION);
1232
1233   bool bValue;
1234   actor.GetProperty(CameraActor::Property::INVERT_Y_AXIS).Get(bValue);
1235   DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
1236   END_TEST;
1237 }
1238
1239 int UtcDaliCameraActorGetCamera(void)
1240 {
1241   TestApplication application;
1242   tet_infoline("Testing Dali::CameraActor::GetCamera()");
1243
1244   CameraActor actor = CameraActor::New();
1245
1246   actor.SetAspectRatio(TEST_ASPECT_RATIO);
1247
1248   DALI_TEST_EQUALS(actor.GetAspectRatio(), TEST_ASPECT_RATIO, FLOAT_EPSILON, TEST_LOCATION);
1249
1250   actor.SetProperty(CameraActor::Property::TYPE, Camera::FREE_LOOK);
1251   actor.SetProperty(CameraActor::Property::ASPECT_RATIO, TEST_ASPECT_RATIO);
1252   actor.SetProperty(CameraActor::Property::FIELD_OF_VIEW, TEST_FIELD_OF_VIEW);
1253   actor.SetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE, TEST_NEAR_PLANE_DISTANCE);
1254   actor.SetProperty(CameraActor::Property::FAR_PLANE_DISTANCE, TEST_FAR_PLANE_DISTANCE);
1255
1256   DALI_TEST_EQUALS(Camera::FREE_LOOK, actor.GetType(), TEST_LOCATION);
1257   DALI_TEST_EQUALS(TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION);
1258   DALI_TEST_EQUALS(TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION);
1259   DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
1260   DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
1261   END_TEST;
1262 }
1263
1264 int UtcDaliCameraActorDefaultProperties(void)
1265 {
1266   TestApplication application;
1267   tet_infoline("Testing Dali::CameraActor DefaultProperties");
1268
1269   CameraActor        actor = CameraActor::New();
1270   Integration::Scene stage = application.GetScene();
1271   stage.Add(actor);
1272   stage.GetRenderTaskList().GetTask(0).SetCameraActor(actor);
1273
1274   actor.SetAspectRatio(TEST_ASPECT_RATIO);
1275   application.GetScene().Add(actor);
1276   application.Render(0);
1277   application.SendNotification();
1278   bool bValue;
1279   actor.GetProperty(CameraActor::Property::INVERT_Y_AXIS).Get(bValue);
1280   DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
1281
1282   std::vector<Property::Index> indices;
1283   indices.push_back(CameraActor::Property::TYPE);
1284   indices.push_back(CameraActor::Property::PROJECTION_MODE);
1285   indices.push_back(CameraActor::Property::FIELD_OF_VIEW);
1286   indices.push_back(CameraActor::Property::ASPECT_RATIO);
1287   indices.push_back(CameraActor::Property::NEAR_PLANE_DISTANCE);
1288   indices.push_back(CameraActor::Property::FAR_PLANE_DISTANCE);
1289   indices.push_back(CameraActor::Property::LEFT_PLANE_DISTANCE);
1290   indices.push_back(CameraActor::Property::RIGHT_PLANE_DISTANCE);
1291   indices.push_back(CameraActor::Property::TOP_PLANE_DISTANCE);
1292   indices.push_back(CameraActor::Property::BOTTOM_PLANE_DISTANCE);
1293   indices.push_back(CameraActor::Property::TARGET_POSITION);
1294   indices.push_back(CameraActor::Property::PROJECTION_MATRIX);
1295   indices.push_back(CameraActor::Property::VIEW_MATRIX);
1296   indices.push_back(CameraActor::Property::INVERT_Y_AXIS);
1297   indices.push_back(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE);
1298   indices.push_back(DevelCameraActor::Property::PROJECTION_DIRECTION);
1299
1300   DALI_TEST_CHECK(actor.GetPropertyCount() == (Actor::New().GetPropertyCount() + indices.size()));
1301
1302   for(std::vector<Property::Index>::iterator iter = indices.begin(); iter != indices.end(); ++iter)
1303   {
1304     DALI_TEST_EQUALS(*iter, actor.GetPropertyIndex(actor.GetPropertyName(*iter)), TEST_LOCATION);
1305
1306     if(*iter == CameraActor::Property::FIELD_OF_VIEW || *iter == CameraActor::Property::ASPECT_RATIO || *iter == DevelCameraActor::Property::ORTHOGRAPHIC_SIZE)
1307     {
1308       DALI_TEST_CHECK(actor.IsPropertyAnimatable(*iter));
1309     }
1310     else
1311     {
1312       DALI_TEST_CHECK(!actor.IsPropertyAnimatable(*iter));
1313     }
1314
1315     if((*iter == CameraActor::Property::LEFT_PLANE_DISTANCE) ||
1316        (*iter == CameraActor::Property::RIGHT_PLANE_DISTANCE) ||
1317        (*iter == CameraActor::Property::TOP_PLANE_DISTANCE) ||
1318        (*iter == CameraActor::Property::BOTTOM_PLANE_DISTANCE) ||
1319        (*iter == CameraActor::Property::PROJECTION_MATRIX) ||
1320        (*iter == CameraActor::Property::VIEW_MATRIX))
1321     {
1322       DALI_TEST_CHECK(!actor.IsPropertyWritable(*iter));
1323     }
1324     else
1325     {
1326       DALI_TEST_CHECK(actor.IsPropertyWritable(*iter));
1327     }
1328
1329     DALI_TEST_CHECK(actor.GetPropertyType(*iter) == actor.GetPropertyType(*iter)); // just checking call succeeds
1330   }
1331
1332   // Set/Get one of them.
1333   const float newAspect = TEST_ASPECT_RATIO * 2.0f;
1334
1335   actor.SetProperty(CameraActor::Property::ASPECT_RATIO, Property::Value(newAspect));
1336   application.Render();
1337   application.SendNotification();
1338   application.Render();
1339   application.SendNotification();
1340
1341   DALI_TEST_EQUALS(actor.GetAspectRatio(), newAspect, TEST_LOCATION);
1342   END_TEST;
1343 }
1344
1345 template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
1346 void TEST_CAMERA_PROPERTY(P1 camera, P2 stringName, P3 type, P4 isWriteable, P5 isAnimateable, P6 isConstraintInput, P7 enumName, P8 LOCATION)
1347 {
1348   DALI_TEST_EQUALS(camera.GetPropertyName(enumName), stringName, LOCATION);
1349   DALI_TEST_EQUALS(camera.GetPropertyIndex(stringName), static_cast<Property::Index>(enumName), LOCATION);
1350   DALI_TEST_EQUALS(camera.GetPropertyType(enumName), type, LOCATION);
1351   DALI_TEST_EQUALS(camera.IsPropertyWritable(enumName), isWriteable, LOCATION);
1352   DALI_TEST_EQUALS(camera.IsPropertyAnimatable(enumName), isAnimateable, LOCATION);
1353   DALI_TEST_EQUALS(camera.IsPropertyAConstraintInput(enumName), isConstraintInput, LOCATION);
1354 }
1355 int UtcDaliCameraActorDefaultPropertiesInherited(void)
1356 {
1357   TestApplication application;
1358
1359   CameraActor        actor = CameraActor::New();
1360   Integration::Scene stage = application.GetScene();
1361   stage.Add(actor);
1362   stage.GetRenderTaskList().GetTask(0).SetCameraActor(actor);
1363
1364   application.GetScene().Add(actor);
1365   application.Render(0);
1366   application.SendNotification();
1367
1368   const PropertyDetails CAMERA_DEFAULT_PROPERTY[] =
1369     {
1370       // actor
1371       {"parentOrigin", Property::VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN},
1372       {"parentOriginX", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X},
1373       {"parentOriginY", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y},
1374       {"parentOriginZ", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z},
1375       {"anchorPoint", Property::VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT},
1376       {"anchorPointX", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X},
1377       {"anchorPointY", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y},
1378       {"anchorPointZ", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z},
1379       {"size", Property::VECTOR3, true, true, true, Dali::Actor::Property::SIZE},
1380       {"sizeWidth", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH},
1381       {"sizeHeight", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT},
1382       {"sizeDepth", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH},
1383       {"position", Property::VECTOR3, true, true, true, Dali::Actor::Property::POSITION},
1384       {"positionX", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_X},
1385       {"positionY", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y},
1386       {"positionZ", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z},
1387       {"worldPosition", Property::VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION},
1388       {"worldPositionX", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X},
1389       {"worldPositionY", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y},
1390       {"worldPositionZ", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z},
1391       {"orientation", Property::ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION},
1392       {"worldOrientation", Property::ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION},
1393       {"scale", Property::VECTOR3, true, true, true, Dali::Actor::Property::SCALE},
1394       {"scaleX", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_X},
1395       {"scaleY", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y},
1396       {"scaleZ", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z},
1397       {"worldScale", Property::VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE},
1398       {"visible", Property::BOOLEAN, true, true, true, Dali::Actor::Property::VISIBLE},
1399       {"color", Property::VECTOR4, true, true, true, Dali::Actor::Property::COLOR},
1400       {"colorRed", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED},
1401       {"colorGreen", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN},
1402       {"colorBlue", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE},
1403       {"colorAlpha", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA},
1404       {"worldColor", Property::VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR},
1405       {"worldMatrix", Property::MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX},
1406       {"name", Property::STRING, true, false, false, Dali::Actor::Property::NAME},
1407       {"sensitive", Property::BOOLEAN, true, false, false, Dali::Actor::Property::SENSITIVE},
1408       {"leaveRequired", Property::BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED},
1409       {"inheritOrientation", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION},
1410       {"inheritScale", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE},
1411       {"colorMode", Property::INTEGER, true, false, false, Dali::Actor::Property::COLOR_MODE},
1412       {"drawMode", Property::INTEGER, true, false, false, Dali::Actor::Property::DRAW_MODE},
1413       {"sizeModeFactor", Property::VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR},
1414       {"widthResizePolicy", Property::STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY},
1415       {"heightResizePolicy", Property::STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY},
1416       {"sizeScalePolicy", Property::INTEGER, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY},
1417       {"widthForHeight", Property::BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT},
1418       {"heightForWidth", Property::BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH},
1419       {"padding", Property::VECTOR4, true, false, false, Dali::Actor::Property::PADDING},
1420       {"minimumSize", Property::VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE},
1421       {"maximumSize", Property::VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE},
1422       {"inheritPosition", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_POSITION},
1423       {"clippingMode", Property::STRING, true, false, false, Dali::Actor::Property::CLIPPING_MODE},
1424       {"layoutDirection", Property::STRING, true, false, false, Dali::Actor::Property::LAYOUT_DIRECTION},
1425       {"inheritLayoutDirection", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION},
1426       {"opacity", Property::FLOAT, true, true, true, Dali::Actor::Property::OPACITY},
1427       {"screenPosition", Property::VECTOR2, false, false, false, Dali::Actor::Property::SCREEN_POSITION},
1428       {"positionUsesAnchorPoint", Property::BOOLEAN, true, false, false, Dali::Actor::Property::POSITION_USES_ANCHOR_POINT},
1429       {"culled", Property::BOOLEAN, false, false, true, Dali::Actor::Property::CULLED},
1430       {"id", Property::INTEGER, false, false, false, Dali::Actor::Property::ID},
1431       {"hierarchyDepth", Property::INTEGER, false, false, false, Dali::Actor::Property::HIERARCHY_DEPTH},
1432       {"isRoot", Property::BOOLEAN, false, false, false, Dali::Actor::Property::IS_ROOT},
1433       {"isLayer", Property::BOOLEAN, false, false, false, Dali::Actor::Property::IS_LAYER},
1434       {"connectedToScene", Property::BOOLEAN, false, false, false, Dali::Actor::Property::CONNECTED_TO_SCENE},
1435       {"keyboardFocusable", Property::BOOLEAN, true, false, false, Dali::Actor::Property::KEYBOARD_FOCUSABLE},
1436       {"siblingOrder", Property::INTEGER, true, false, false, Dali::DevelActor::Property::SIBLING_ORDER},
1437       // camera own
1438       {"type", Property::INTEGER, true, false, true, Dali::CameraActor::Property::TYPE},
1439       {"projectionMode", Property::INTEGER, true, false, true, Dali::CameraActor::Property::PROJECTION_MODE},
1440       {"fieldOfView", Property::FLOAT, true, true, true, Dali::CameraActor::Property::FIELD_OF_VIEW},
1441       {"aspectRatio", Property::FLOAT, true, true, true, Dali::CameraActor::Property::ASPECT_RATIO},
1442       {"nearPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::NEAR_PLANE_DISTANCE},
1443       {"farPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::FAR_PLANE_DISTANCE},
1444       {"leftPlaneDistance", Property::FLOAT, false, false, true, Dali::CameraActor::Property::LEFT_PLANE_DISTANCE},
1445       {"rightPlaneDistance", Property::FLOAT, false, false, true, Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE},
1446       {"topPlaneDistance", Property::FLOAT, false, false, true, Dali::CameraActor::Property::TOP_PLANE_DISTANCE},
1447       {"bottomPlaneDistance", Property::FLOAT, false, false, true, Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE},
1448       {"targetPosition", Property::VECTOR3, true, false, true, Dali::CameraActor::Property::TARGET_POSITION},
1449       {"projectionMatrix", Property::MATRIX, false, false, true, Dali::CameraActor::Property::PROJECTION_MATRIX},
1450       {"viewMatrix", Property::MATRIX, false, false, true, Dali::CameraActor::Property::VIEW_MATRIX},
1451       {"invertYAxis", Property::BOOLEAN, true, false, true, Dali::CameraActor::Property::INVERT_Y_AXIS},
1452       {"orthographicSize", Property::FLOAT, true, true, true, Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE},
1453       {"projectionDirection", Property::INTEGER, true, false, true, Dali::DevelCameraActor::Property::PROJECTION_DIRECTION}};
1454
1455   for(uint32_t index = 0; index < (sizeof(CAMERA_DEFAULT_PROPERTY) / sizeof(PropertyDetails)); ++index)
1456   {
1457     TEST_CAMERA_PROPERTY(actor,
1458                          CAMERA_DEFAULT_PROPERTY[index].name,
1459                          CAMERA_DEFAULT_PROPERTY[index].type,
1460                          CAMERA_DEFAULT_PROPERTY[index].writable,
1461                          CAMERA_DEFAULT_PROPERTY[index].animatable,
1462                          CAMERA_DEFAULT_PROPERTY[index].constraintInput,
1463                          CAMERA_DEFAULT_PROPERTY[index].enumIndex,
1464                          TEST_LOCATION);
1465   }
1466   END_TEST;
1467 }
1468
1469 int UtcDaliCameraActorModelView(void)
1470 {
1471   TestApplication application;
1472   tet_infoline("Testing Dali::CameraActor Test view application");
1473
1474   Actor actor = CreateRenderableActor();
1475   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1476   actor.SetProperty(Actor::Property::POSITION, Vector3(20.0f, 30.0f, 40.0f));
1477   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1478   application.GetScene().Add(actor);
1479
1480   application.SendNotification();
1481   application.Render(0);
1482   application.Render();
1483   application.SendNotification();
1484
1485   Matrix resultMatrix(true);
1486   resultMatrix.SetTransformComponents(Vector3::ONE, Quaternion::IDENTITY, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1487
1488   RenderTask  task        = application.GetScene().GetRenderTaskList().GetTask(0);
1489   CameraActor cameraActor = task.GetCameraActor();
1490
1491   Matrix viewMatrix(false);
1492   cameraActor.GetProperty(CameraActor::Property::VIEW_MATRIX).Get(viewMatrix);
1493   Matrix::Multiply(resultMatrix, resultMatrix, viewMatrix);
1494
1495   DALI_TEST_CHECK(application.GetGlAbstraction().CheckUniformValue("uModelView", resultMatrix));
1496   END_TEST;
1497 }
1498
1499 int UtcDaliCameraActorReadProjectionMatrix(void)
1500 {
1501   TestApplication application;
1502   tet_infoline("Testing Dali::CameraActor::ReadProjectionMatrix()");
1503
1504   CameraActor camera = application.GetScene().GetRenderTaskList().GetTask(0u).GetCameraActor();
1505   application.SendNotification();
1506   application.Render(0);
1507   application.Render();
1508   application.SendNotification();
1509   Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 4u, 4u);
1510   Actor   actor = CreateRenderableActor(image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE);
1511   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1512   application.GetScene().Add(actor);
1513
1514   Matrix projectionMatrix;
1515   Matrix viewMatrix;
1516
1517   camera.GetProperty(CameraActor::CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
1518   camera.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(viewMatrix);
1519
1520   actor.RegisterProperty(SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME, Matrix::IDENTITY);
1521   actor.RegisterProperty(SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME, Matrix::IDENTITY);
1522
1523   Property::Index projectionMatrixPropertyIndex = actor.GetPropertyIndex(SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME);
1524   Property::Index viewMatrixPropertyIndex       = actor.GetPropertyIndex(SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME);
1525
1526   Constraint projectionMatrixConstraint = Constraint::New<Dali::Matrix>(actor, projectionMatrixPropertyIndex, EqualToConstraint());
1527   projectionMatrixConstraint.AddSource(Source(camera, CameraActor::Property::PROJECTION_MATRIX));
1528   Constraint viewMatrixConstraint = Constraint::New<Dali::Matrix>(actor, viewMatrixPropertyIndex, EqualToConstraint());
1529   viewMatrixConstraint.AddSource(Source(camera, CameraActor::Property::VIEW_MATRIX));
1530
1531   projectionMatrixConstraint.Apply();
1532   viewMatrixConstraint.Apply();
1533
1534   application.SendNotification();
1535   application.Render();
1536
1537   // Test effects of Constraint.
1538   DALI_TEST_CHECK(application.GetGlAbstraction().CheckUniformValue(SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME.c_str(), projectionMatrix));
1539
1540   DALI_TEST_CHECK(application.GetGlAbstraction().CheckUniformValue(SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME.c_str(), viewMatrix));
1541   END_TEST;
1542 }
1543
1544 int UtcDaliCameraActorAnimatedProperties01(void)
1545 {
1546   TestApplication application;
1547   tet_infoline("Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()");
1548
1549   CameraActor camera = application.GetScene().GetRenderTaskList().GetTask(0u).GetCameraActor();
1550   Actor       actor  = Actor::New();
1551   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1552   application.GetScene().Add(actor);
1553
1554   Constraint constraint = Constraint::New<Dali::Vector3>(actor, Actor::Property::POSITION, EqualToConstraint());
1555   constraint.AddSource(Source(camera, Actor::Property::POSITION));
1556   constraint.Apply();
1557
1558   camera.SetProperty(Actor::Property::POSITION, Vector3(100.0f, 200.0f, 300.0f));
1559   application.SendNotification();
1560   application.Render();
1561
1562   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(100.0f, 200.0f, 300.0f), TEST_LOCATION);
1563   END_TEST;
1564 }
1565
1566 int UtcDaliCameraActorAnimatedProperties02(void)
1567 {
1568   TestApplication application;
1569   tet_infoline("Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()");
1570
1571   CameraActor camera = application.GetScene().GetRenderTaskList().GetTask(0u).GetCameraActor();
1572   Actor       actor  = Actor::New();
1573   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1574   actor.SetProperty(Actor::Property::POSITION, Vector2(0.1f, 0.0f));
1575   application.GetScene().Add(actor);
1576
1577   camera.SetFieldOfView(0.1f);
1578   camera.SetAspectRatio(0.5f);
1579   camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, 200.0f);
1580
1581   Constraint constraintX = Constraint::New<float>(actor, Actor::Property::POSITION_X, EqualToConstraint());
1582   constraintX.AddSource(Source(camera, CameraActor::Property::FIELD_OF_VIEW));
1583   constraintX.Apply();
1584
1585   Constraint constraintY = Constraint::New<float>(actor, Actor::Property::POSITION_Y, EqualToConstraint());
1586   constraintY.AddSource(Source(camera, CameraActor::Property::ASPECT_RATIO));
1587   constraintY.Apply();
1588
1589   Constraint constraintZ = Constraint::New<float>(actor, Actor::Property::POSITION_Z, EqualToConstraint());
1590   constraintZ.AddSource(Source(camera, DevelCameraActor::Property::ORTHOGRAPHIC_SIZE));
1591   constraintZ.Apply();
1592
1593   application.SendNotification();
1594   application.Render();
1595
1596   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), 0.1f, TEST_LOCATION);
1597   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_Y), 0.5f, TEST_LOCATION);
1598   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_Z), 200.0f, TEST_LOCATION);
1599
1600   camera.SetFieldOfView(0.5f);
1601   camera.SetAspectRatio(0.2f);
1602   camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, 100.0f);
1603
1604   application.SendNotification();
1605   application.Render();
1606
1607   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), 0.5f, TEST_LOCATION);
1608   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_Y), 0.2f, TEST_LOCATION);
1609   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_Z), 100.0f, TEST_LOCATION);
1610   END_TEST;
1611 }
1612
1613 int UtcDaliCameraActorAnimatedProperties03(void)
1614 {
1615   TestApplication application;
1616   tet_infoline("Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()");
1617
1618   CameraActor camera = application.GetScene().GetRenderTaskList().GetTask(0u).GetCameraActor();
1619
1620   // Add dummy actor
1621   Actor actor = Actor::New();
1622   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1623   actor.SetProperty(Actor::Property::POSITION, Vector2(0.1f, 0.0f));
1624   application.GetScene().Add(actor);
1625
1626   Radian sourceFoV    = Radian(0.6f);
1627   float  sourceAspect = 0.7f;
1628
1629   Radian targetFoV    = Radian(0.1f);
1630   float  targetAspect = 1.3f;
1631
1632   Matrix expectedProjectionMatrix1;
1633   Matrix expectedProjectionMatrix2;
1634   Matrix expectedProjectionMatrix3;
1635
1636   // Reduce near-far value for projection matrix epsilon
1637   camera.SetNearClippingPlane(1.0f);
1638   camera.SetFarClippingPlane(3.0f);
1639
1640   // Build expect projection matrix
1641   camera.SetFieldOfView(sourceFoV.radian);
1642   camera.SetAspectRatio(sourceAspect);
1643   application.SendNotification();
1644   application.Render();
1645   camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(expectedProjectionMatrix1);
1646
1647   camera.SetFieldOfView(sourceFoV.radian * 0.6f + targetFoV.radian * 0.4f);
1648   camera.SetAspectRatio(sourceAspect * 0.6f + targetAspect * 0.4f);
1649   application.SendNotification();
1650   application.Render();
1651   camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(expectedProjectionMatrix2);
1652
1653   camera.SetFieldOfView(targetFoV.radian);
1654   camera.SetAspectRatio(targetAspect);
1655   application.SendNotification();
1656   application.Render();
1657   camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(expectedProjectionMatrix3);
1658
1659   auto TestAnimationProgress = [&]() {
1660     Matrix projectionMatrix;
1661
1662     application.SendNotification();
1663     application.Render(0);
1664
1665     // progress 0.0
1666     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::FIELD_OF_VIEW), sourceFoV.radian, TEST_LOCATION);
1667     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::ASPECT_RATIO), sourceAspect, TEST_LOCATION);
1668
1669     camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
1670     DALI_TEST_EQUALS(projectionMatrix, expectedProjectionMatrix1, Epsilon<100000>::value, TEST_LOCATION);
1671
1672     application.SendNotification();
1673     application.Render(400);
1674
1675     // progress 0.4
1676     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::FIELD_OF_VIEW), sourceFoV.radian * 0.6f + targetFoV.radian * 0.4f, TEST_LOCATION);
1677     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::ASPECT_RATIO), sourceAspect * 0.6f + targetAspect * 0.4f, TEST_LOCATION);
1678
1679     camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
1680     DALI_TEST_EQUALS(projectionMatrix, expectedProjectionMatrix2, Epsilon<100000>::value, TEST_LOCATION);
1681
1682     application.SendNotification();
1683     application.Render(600);
1684
1685     // progress 1.0
1686     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::FIELD_OF_VIEW), targetFoV.radian, TEST_LOCATION);
1687     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::ASPECT_RATIO), targetAspect, TEST_LOCATION);
1688
1689     camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
1690     DALI_TEST_EQUALS(projectionMatrix, expectedProjectionMatrix3, Epsilon<100000>::value, TEST_LOCATION);
1691
1692     // Ensure Animate finished.
1693     application.SendNotification();
1694     application.Render(16);
1695   };
1696
1697   // AnimateTo
1698   {
1699     tet_printf("AnimateTo\n");
1700     camera.SetProperty(CameraActor::Property::FIELD_OF_VIEW, sourceFoV.radian);
1701     camera.SetProperty(CameraActor::Property::ASPECT_RATIO, sourceAspect);
1702     Animation animation = Animation::New(1.0f);
1703     animation.AnimateTo(Property(camera, CameraActor::Property::FIELD_OF_VIEW), targetFoV.radian);
1704     animation.AnimateTo(Property(camera, CameraActor::Property::ASPECT_RATIO), targetAspect);
1705     animation.AnimateTo(Property(camera, Actor::Property::POSITION_X), 0.0f); ///< For line coverage.
1706     animation.Play();
1707
1708     TestAnimationProgress();
1709   }
1710
1711   // AnimateBetween
1712   {
1713     tet_printf("AnimateBetween\n");
1714     Animation animation = Animation::New(1.0f);
1715
1716     KeyFrames keyFrames1 = KeyFrames::New();
1717     keyFrames1.Add(0.0f, sourceFoV.radian);
1718     keyFrames1.Add(1.0f, targetFoV.radian);
1719
1720     KeyFrames keyFrames2 = KeyFrames::New();
1721     keyFrames2.Add(0.0f, sourceAspect);
1722     keyFrames2.Add(1.0f, targetAspect);
1723
1724     animation.AnimateBetween(Property(camera, CameraActor::Property::FIELD_OF_VIEW), keyFrames1);
1725     animation.AnimateBetween(Property(camera, CameraActor::Property::ASPECT_RATIO), keyFrames2);
1726
1727     animation.Play();
1728
1729     TestAnimationProgress();
1730   }
1731
1732   // AnimateBy
1733   {
1734     tet_printf("AnimateBy\n");
1735     camera.SetProperty(CameraActor::Property::FIELD_OF_VIEW, sourceFoV.radian);
1736     camera.SetProperty(CameraActor::Property::ASPECT_RATIO, sourceAspect);
1737     Animation animation = Animation::New(1.0f);
1738     animation.AnimateBy(Property(camera, CameraActor::Property::FIELD_OF_VIEW), targetFoV.radian - sourceFoV.radian);
1739     animation.AnimateBy(Property(camera, CameraActor::Property::ASPECT_RATIO), targetAspect - sourceAspect);
1740     animation.Play();
1741
1742     TestAnimationProgress();
1743   }
1744
1745   END_TEST;
1746 }
1747
1748 int UtcDaliCameraActorAnimatedProperties04(void)
1749 {
1750   TestApplication application;
1751   tet_infoline("Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()");
1752
1753   CameraActor camera = application.GetScene().GetRenderTaskList().GetTask(0u).GetCameraActor();
1754
1755   // Make camera as orthographic mode
1756   camera.SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION);
1757
1758   // Add dummy actor
1759   Actor actor = Actor::New();
1760   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1761   actor.SetProperty(Actor::Property::POSITION, Vector2(0.1f, 0.0f));
1762   application.GetScene().Add(actor);
1763
1764   float sourceOrthographic = 2.0f;
1765   float sourceAspect       = 0.7f;
1766
1767   float targetOrthographic = 4.0f;
1768   float targetAspect       = 1.3f;
1769
1770   Matrix expectedProjectionMatrix1;
1771   Matrix expectedProjectionMatrix2;
1772   Matrix expectedProjectionMatrix3;
1773
1774   // Reduce near-far value for projection matrix epsilon
1775   camera.SetNearClippingPlane(1.0f);
1776   camera.SetFarClippingPlane(3.0f);
1777
1778   // Build expect projection matrix
1779   camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, sourceOrthographic);
1780   camera.SetAspectRatio(sourceAspect);
1781   application.SendNotification();
1782   application.Render();
1783   camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(expectedProjectionMatrix1);
1784
1785   camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, sourceOrthographic * 0.6f + targetOrthographic * 0.4f);
1786   camera.SetAspectRatio(sourceAspect * 0.6f + targetAspect * 0.4f);
1787   application.SendNotification();
1788   application.Render();
1789   camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(expectedProjectionMatrix2);
1790
1791   camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, targetOrthographic);
1792   camera.SetAspectRatio(targetAspect);
1793   application.SendNotification();
1794   application.Render();
1795   camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(expectedProjectionMatrix3);
1796
1797   auto TestAnimationProgress = [&]() {
1798     Matrix projectionMatrix;
1799
1800     application.SendNotification();
1801     application.Render(0);
1802
1803     float expectOrthographic;
1804     float expectAspect;
1805     float expectLeft;
1806     float expectRight;
1807     float expectTop;
1808     float expectBottom;
1809
1810     auto UpdateExpectPlaneDistance = [&]() {
1811       bool isVertical = camera.GetProperty<int>(DevelCameraActor::Property::PROJECTION_DIRECTION) == static_cast<int>(DevelCameraActor::ProjectionDirection::VERTICAL);
1812       expectLeft      = -(isVertical ? expectOrthographic * expectAspect : expectOrthographic);
1813       expectRight     = (isVertical ? expectOrthographic * expectAspect : expectOrthographic);
1814       expectTop       = (isVertical ? expectOrthographic : expectOrthographic / expectAspect);
1815       expectBottom    = -(isVertical ? expectOrthographic : expectOrthographic / expectAspect);
1816     };
1817
1818     // progress 0.0
1819     expectOrthographic = sourceOrthographic;
1820     expectAspect       = sourceAspect;
1821     UpdateExpectPlaneDistance();
1822     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), expectOrthographic, TEST_LOCATION);
1823     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::ASPECT_RATIO), expectAspect, TEST_LOCATION);
1824     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::LEFT_PLANE_DISTANCE), expectLeft, TEST_LOCATION);
1825     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::RIGHT_PLANE_DISTANCE), expectRight, TEST_LOCATION);
1826     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::TOP_PLANE_DISTANCE), expectTop, TEST_LOCATION);
1827     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::BOTTOM_PLANE_DISTANCE), expectBottom, TEST_LOCATION);
1828
1829     camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
1830     DALI_TEST_EQUALS(projectionMatrix, expectedProjectionMatrix1, Epsilon<100000>::value, TEST_LOCATION);
1831
1832     application.SendNotification();
1833     application.Render(400);
1834
1835     // progress 0.4
1836     expectOrthographic = sourceOrthographic * 0.6f + targetOrthographic * 0.4f;
1837     expectAspect       = sourceAspect * 0.6f + targetAspect * 0.4f;
1838     UpdateExpectPlaneDistance();
1839     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), expectOrthographic, TEST_LOCATION);
1840     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::ASPECT_RATIO), expectAspect, TEST_LOCATION);
1841     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::LEFT_PLANE_DISTANCE), expectLeft, TEST_LOCATION);
1842     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::RIGHT_PLANE_DISTANCE), expectRight, TEST_LOCATION);
1843     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::TOP_PLANE_DISTANCE), expectTop, TEST_LOCATION);
1844     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::BOTTOM_PLANE_DISTANCE), expectBottom, TEST_LOCATION);
1845
1846     camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
1847     DALI_TEST_EQUALS(projectionMatrix, expectedProjectionMatrix2, Epsilon<100000>::value, TEST_LOCATION);
1848
1849     application.SendNotification();
1850     application.Render(600);
1851
1852     // progress 1.0
1853     expectOrthographic = targetOrthographic;
1854     expectAspect       = targetAspect;
1855     UpdateExpectPlaneDistance();
1856     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), expectOrthographic, TEST_LOCATION);
1857     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::ASPECT_RATIO), expectAspect, TEST_LOCATION);
1858     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::LEFT_PLANE_DISTANCE), expectLeft, TEST_LOCATION);
1859     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::RIGHT_PLANE_DISTANCE), expectRight, TEST_LOCATION);
1860     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::TOP_PLANE_DISTANCE), expectTop, TEST_LOCATION);
1861     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::BOTTOM_PLANE_DISTANCE), expectBottom, TEST_LOCATION);
1862
1863     camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
1864     DALI_TEST_EQUALS(projectionMatrix, expectedProjectionMatrix3, Epsilon<100000>::value, TEST_LOCATION);
1865
1866     // Ensure Animate finished.
1867     application.SendNotification();
1868     application.Render(16);
1869   };
1870
1871   // AnimateTo
1872   {
1873     tet_printf("AnimateTo - vertical\n");
1874     camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, sourceOrthographic);
1875     camera.SetProperty(CameraActor::Property::ASPECT_RATIO, sourceAspect);
1876     Animation animation = Animation::New(1.0f);
1877     animation.AnimateTo(Property(camera, DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), targetOrthographic);
1878     animation.AnimateTo(Property(camera, CameraActor::Property::ASPECT_RATIO), targetAspect);
1879     animation.Play();
1880     TestAnimationProgress();
1881   }
1882
1883   // AnimateBetween
1884   {
1885     tet_printf("AnimateBetween - vertical\n");
1886     Animation animation = Animation::New(1.0f);
1887
1888     KeyFrames keyFrames1 = KeyFrames::New();
1889     keyFrames1.Add(0.0f, sourceOrthographic);
1890     keyFrames1.Add(1.0f, targetOrthographic);
1891
1892     KeyFrames keyFrames2 = KeyFrames::New();
1893     keyFrames2.Add(0.0f, sourceAspect);
1894     keyFrames2.Add(1.0f, targetAspect);
1895
1896     animation.AnimateBetween(Property(camera, DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), keyFrames1);
1897     animation.AnimateBetween(Property(camera, CameraActor::Property::ASPECT_RATIO), keyFrames2);
1898
1899     animation.Play();
1900     TestAnimationProgress();
1901   }
1902
1903   // AnimateBy
1904   {
1905     tet_printf("AnimateBy - vertical\n");
1906     camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, sourceOrthographic);
1907     camera.SetProperty(CameraActor::Property::ASPECT_RATIO, sourceAspect);
1908     Animation animation = Animation::New(1.0f);
1909     animation.AnimateBy(Property(camera, DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), targetOrthographic - sourceOrthographic);
1910     animation.AnimateBy(Property(camera, CameraActor::Property::ASPECT_RATIO), targetAspect - sourceAspect);
1911     animation.Play();
1912     TestAnimationProgress();
1913   }
1914
1915   END_TEST;
1916 }
1917
1918 int UtcDaliCameraActorAnimatedProperties05(void)
1919 {
1920   TestApplication application;
1921   tet_infoline("Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()");
1922
1923   CameraActor camera = application.GetScene().GetRenderTaskList().GetTask(0u).GetCameraActor();
1924
1925   // Make camera as orthographic mode and horizontal
1926   camera.SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION);
1927   camera.SetProperty(DevelCameraActor::Property::PROJECTION_DIRECTION, DevelCameraActor::ProjectionDirection::HORIZONTAL);
1928
1929   // Add dummy actor
1930   Actor actor = Actor::New();
1931   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
1932   actor.SetProperty(Actor::Property::POSITION, Vector2(0.1f, 0.0f));
1933   application.GetScene().Add(actor);
1934
1935   float sourceOrthographic = 2.0f;
1936   float sourceAspect       = 0.7f;
1937
1938   float targetOrthographic = 4.0f;
1939   float targetAspect       = 1.3f;
1940
1941   Matrix expectedProjectionMatrix1;
1942   Matrix expectedProjectionMatrix2;
1943   Matrix expectedProjectionMatrix3;
1944
1945   // Reduce near-far value for projection matrix epsilon
1946   camera.SetNearClippingPlane(1.0f);
1947   camera.SetFarClippingPlane(3.0f);
1948
1949   // Build expect projection matrix
1950   camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, sourceOrthographic);
1951   camera.SetAspectRatio(sourceAspect);
1952   application.SendNotification();
1953   application.Render();
1954   camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(expectedProjectionMatrix1);
1955
1956   camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, sourceOrthographic * 0.6f + targetOrthographic * 0.4f);
1957   camera.SetAspectRatio(sourceAspect * 0.6f + targetAspect * 0.4f);
1958   application.SendNotification();
1959   application.Render();
1960   camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(expectedProjectionMatrix2);
1961
1962   camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, targetOrthographic);
1963   camera.SetAspectRatio(targetAspect);
1964   application.SendNotification();
1965   application.Render();
1966   camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(expectedProjectionMatrix3);
1967
1968   auto TestAnimationProgress = [&]() {
1969     Matrix projectionMatrix;
1970
1971     application.SendNotification();
1972     application.Render(0);
1973
1974     float expectOrthographic;
1975     float expectAspect;
1976     float expectLeft;
1977     float expectRight;
1978     float expectTop;
1979     float expectBottom;
1980
1981     auto UpdateExpectPlaneDistance = [&]() {
1982       bool isVertical = camera.GetProperty<int>(DevelCameraActor::Property::PROJECTION_DIRECTION) == static_cast<int>(DevelCameraActor::ProjectionDirection::VERTICAL);
1983       expectLeft      = -(isVertical ? expectOrthographic * expectAspect : expectOrthographic);
1984       expectRight     = (isVertical ? expectOrthographic * expectAspect : expectOrthographic);
1985       expectTop       = (isVertical ? expectOrthographic : expectOrthographic / expectAspect);
1986       expectBottom    = -(isVertical ? expectOrthographic : expectOrthographic / expectAspect);
1987     };
1988
1989     // progress 0.0
1990     expectOrthographic = sourceOrthographic;
1991     expectAspect       = sourceAspect;
1992     UpdateExpectPlaneDistance();
1993     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), expectOrthographic, TEST_LOCATION);
1994     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::ASPECT_RATIO), expectAspect, TEST_LOCATION);
1995     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::LEFT_PLANE_DISTANCE), expectLeft, TEST_LOCATION);
1996     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::RIGHT_PLANE_DISTANCE), expectRight, TEST_LOCATION);
1997     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::TOP_PLANE_DISTANCE), expectTop, TEST_LOCATION);
1998     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::BOTTOM_PLANE_DISTANCE), expectBottom, TEST_LOCATION);
1999
2000     camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
2001     DALI_TEST_EQUALS(projectionMatrix, expectedProjectionMatrix1, Epsilon<100000>::value, TEST_LOCATION);
2002
2003     application.SendNotification();
2004     application.Render(400);
2005
2006     // progress 0.4
2007     expectOrthographic = sourceOrthographic * 0.6f + targetOrthographic * 0.4f;
2008     expectAspect       = sourceAspect * 0.6f + targetAspect * 0.4f;
2009     UpdateExpectPlaneDistance();
2010     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), expectOrthographic, TEST_LOCATION);
2011     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::ASPECT_RATIO), expectAspect, TEST_LOCATION);
2012     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::LEFT_PLANE_DISTANCE), expectLeft, TEST_LOCATION);
2013     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::RIGHT_PLANE_DISTANCE), expectRight, TEST_LOCATION);
2014     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::TOP_PLANE_DISTANCE), expectTop, TEST_LOCATION);
2015     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::BOTTOM_PLANE_DISTANCE), expectBottom, TEST_LOCATION);
2016
2017     camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
2018     DALI_TEST_EQUALS(projectionMatrix, expectedProjectionMatrix2, Epsilon<100000>::value, TEST_LOCATION);
2019
2020     application.SendNotification();
2021     application.Render(600);
2022
2023     // progress 1.0
2024     expectOrthographic = targetOrthographic;
2025     expectAspect       = targetAspect;
2026     UpdateExpectPlaneDistance();
2027     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), expectOrthographic, TEST_LOCATION);
2028     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::ASPECT_RATIO), expectAspect, TEST_LOCATION);
2029     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::LEFT_PLANE_DISTANCE), expectLeft, TEST_LOCATION);
2030     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::RIGHT_PLANE_DISTANCE), expectRight, TEST_LOCATION);
2031     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::TOP_PLANE_DISTANCE), expectTop, TEST_LOCATION);
2032     DALI_TEST_EQUALS(camera.GetCurrentProperty<float>(CameraActor::Property::BOTTOM_PLANE_DISTANCE), expectBottom, TEST_LOCATION);
2033
2034     camera.GetProperty(CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
2035     DALI_TEST_EQUALS(projectionMatrix, expectedProjectionMatrix3, Epsilon<100000>::value, TEST_LOCATION);
2036
2037     // Ensure Animate finished.
2038     application.SendNotification();
2039     application.Render(16);
2040   };
2041
2042   // AnimateTo
2043   {
2044     tet_printf("AnimateTo - horizontal\n");
2045     camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, sourceOrthographic);
2046     camera.SetProperty(CameraActor::Property::ASPECT_RATIO, sourceAspect);
2047     Animation animation = Animation::New(1.0f);
2048     animation.AnimateTo(Property(camera, DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), targetOrthographic);
2049     animation.AnimateTo(Property(camera, CameraActor::Property::ASPECT_RATIO), targetAspect);
2050     animation.Play();
2051     TestAnimationProgress();
2052   }
2053
2054   // AnimateBetween
2055   {
2056     tet_printf("AnimateBetween - horizontal\n");
2057     Animation animation = Animation::New(1.0f);
2058
2059     KeyFrames keyFrames1 = KeyFrames::New();
2060     keyFrames1.Add(0.0f, sourceOrthographic);
2061     keyFrames1.Add(1.0f, targetOrthographic);
2062
2063     KeyFrames keyFrames2 = KeyFrames::New();
2064     keyFrames2.Add(0.0f, sourceAspect);
2065     keyFrames2.Add(1.0f, targetAspect);
2066
2067     animation.AnimateBetween(Property(camera, DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), keyFrames1);
2068     animation.AnimateBetween(Property(camera, CameraActor::Property::ASPECT_RATIO), keyFrames2);
2069
2070     animation.Play();
2071     TestAnimationProgress();
2072   }
2073
2074   // AnimateBy
2075   {
2076     tet_printf("AnimateBy - horizontal\n");
2077     camera.SetProperty(Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE, sourceOrthographic);
2078     camera.SetProperty(CameraActor::Property::ASPECT_RATIO, sourceAspect);
2079     Animation animation = Animation::New(1.0f);
2080     animation.AnimateBy(Property(camera, DevelCameraActor::Property::ORTHOGRAPHIC_SIZE), targetOrthographic - sourceOrthographic);
2081     animation.AnimateBy(Property(camera, CameraActor::Property::ASPECT_RATIO), targetAspect - sourceAspect);
2082     animation.Play();
2083     TestAnimationProgress();
2084   }
2085
2086   END_TEST;
2087 }
2088
2089 int UtcDaliCameraActorPropertyIndices(void)
2090 {
2091   TestApplication application;
2092   CameraActor     camera = application.GetScene().GetRenderTaskList().GetTask(0u).GetCameraActor();
2093
2094   Actor                    basicActor = Actor::New();
2095   Property::IndexContainer indices;
2096   camera.GetPropertyIndices(indices);
2097   DALI_TEST_CHECK(indices.Size() > basicActor.GetPropertyCount());
2098   DALI_TEST_EQUALS(indices.Size(), camera.GetPropertyCount(), TEST_LOCATION);
2099   END_TEST;
2100 }
2101
2102 int UtcDaliCameraActorCheckLookAtAndFreeLookViews01(void)
2103 {
2104   TestApplication    application;
2105   Integration::Scene stage     = application.GetScene();
2106   Vector2            stageSize = stage.GetSize();
2107
2108   CameraActor freeLookCameraActor = CameraActor::New(stageSize);
2109   freeLookCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2110   freeLookCameraActor.SetType(Camera::FREE_LOOK);
2111
2112   Vector3 targetPosition(30.0f, 240.0f, -256.0f);
2113   Actor   target = Actor::New();
2114   target.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2115   target.SetProperty(Actor::Property::POSITION, targetPosition);
2116
2117   Constraint cameraOrientationConstraint = Constraint::New<Quaternion>(freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt);
2118   cameraOrientationConstraint.AddSource(Source(target, Actor::Property::WORLD_POSITION));
2119   cameraOrientationConstraint.AddSource(Source(freeLookCameraActor, Actor::Property::WORLD_POSITION));
2120   cameraOrientationConstraint.AddSource(Source(target, Actor::Property::WORLD_ORIENTATION));
2121   cameraOrientationConstraint.Apply();
2122
2123   CameraActor lookAtCameraActor = CameraActor::New(stageSize);
2124   lookAtCameraActor.SetType(Camera::LOOK_AT_TARGET);
2125   lookAtCameraActor.SetTargetPosition(targetPosition);
2126   lookAtCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2127
2128   stage.Add(target);
2129   stage.Add(freeLookCameraActor);
2130   stage.Add(lookAtCameraActor);
2131
2132   // Create an arbitrary vector
2133   for(float x = -1.0f; x <= 1.0f; x += 0.1f)
2134   {
2135     for(float y = -1.0f; y < 1.0f; y += 0.1f)
2136     {
2137       for(float z = -1.0f; z < 1.0f; z += 0.1f)
2138       {
2139         Vector3 position(x, y, z);
2140         position.Normalize();
2141         position *= 200.0f;
2142
2143         freeLookCameraActor.SetProperty(Actor::Property::POSITION, position);
2144         lookAtCameraActor.SetProperty(Actor::Property::POSITION, position);
2145
2146         application.SendNotification();
2147         application.Render();
2148         application.SendNotification();
2149         application.Render();
2150         Matrix freeLookViewMatrix;
2151         Matrix lookAtViewMatrix;
2152         freeLookCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(freeLookViewMatrix);
2153         lookAtCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(lookAtViewMatrix);
2154
2155         DALI_TEST_EQUALS(freeLookViewMatrix, lookAtViewMatrix, 0.01, TEST_LOCATION);
2156       }
2157     }
2158   }
2159   END_TEST;
2160 }
2161
2162 int UtcDaliCameraActorCheckLookAtAndFreeLookViews02(void)
2163 {
2164   TestApplication    application;
2165   Integration::Scene stage     = application.GetScene();
2166   Vector2            stageSize = stage.GetSize();
2167
2168   CameraActor freeLookCameraActor = CameraActor::New(stageSize);
2169   freeLookCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2170   freeLookCameraActor.SetType(Camera::FREE_LOOK);
2171
2172   Vector3 targetPosition(30.0f, 240.0f, -256.0f);
2173   Actor   target = Actor::New();
2174   target.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2175   target.SetProperty(Actor::Property::POSITION, targetPosition);
2176
2177   Constraint cameraOrientationConstraint = Constraint::New<Quaternion>(freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt);
2178   cameraOrientationConstraint.AddSource(Source(target, Actor::Property::WORLD_POSITION));
2179   cameraOrientationConstraint.AddSource(Source(freeLookCameraActor, Actor::Property::WORLD_POSITION));
2180   cameraOrientationConstraint.AddSource(Source(target, Actor::Property::WORLD_ORIENTATION));
2181   cameraOrientationConstraint.Apply();
2182
2183   CameraActor lookAtCameraActor = CameraActor::New(stageSize);
2184   lookAtCameraActor.SetType(Camera::LOOK_AT_TARGET);
2185   lookAtCameraActor.SetTargetPosition(targetPosition);
2186   lookAtCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2187
2188   stage.Add(target);
2189   stage.Add(freeLookCameraActor);
2190   stage.Add(lookAtCameraActor);
2191   stage.GetRenderTaskList().GetTask(0).SetCameraActor(freeLookCameraActor);
2192
2193   // Create an arbitrary vector
2194   for(float x = -1.0f; x <= 1.0f; x += 0.1f)
2195   {
2196     for(float y = -1.0f; y < 1.0f; y += 0.1f)
2197     {
2198       for(float z = -1.0f; z < 1.0f; z += 0.1f)
2199       {
2200         Vector3 position(x, y, z);
2201         position.Normalize();
2202         position *= 200.0f;
2203
2204         freeLookCameraActor.SetProperty(Actor::Property::POSITION, position);
2205         lookAtCameraActor.SetProperty(Actor::Property::POSITION, position);
2206
2207         application.SendNotification();
2208         application.Render();
2209         application.SendNotification();
2210         application.Render();
2211         Matrix freeLookViewMatrix;
2212         freeLookCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(freeLookViewMatrix);
2213
2214         Matrix freeLookWorld = freeLookCameraActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
2215
2216         Matrix freeLookTest(false);
2217         Matrix::Multiply(freeLookTest, freeLookViewMatrix, freeLookWorld);
2218         DALI_TEST_EQUALS(freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION);
2219       }
2220     }
2221   }
2222
2223   END_TEST;
2224 }
2225
2226 int UtcDaliCameraActorCheckLookAtAndFreeLookViews03(void)
2227 {
2228   TestApplication    application;
2229   Integration::Scene stage     = application.GetScene();
2230   Vector2            stageSize = stage.GetSize();
2231
2232   Vector3 targetPosition(Vector3::ZERO);
2233   Vector3 cameraOffset(0.0f, 0.0f, 100.0f);
2234
2235   CameraActor freeLookCameraActor = CameraActor::New(stageSize);
2236   freeLookCameraActor.SetType(Camera::FREE_LOOK);
2237   freeLookCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2238
2239   Quaternion cameraOrientation(Radian(Degree(180.0f)), Vector3::YAXIS);
2240   freeLookCameraActor.SetProperty(Actor::Property::POSITION, cameraOffset);
2241   freeLookCameraActor.SetProperty(Actor::Property::ORIENTATION, cameraOrientation);
2242
2243   Actor cameraAnchor = Actor::New();
2244   cameraAnchor.Add(freeLookCameraActor);
2245   stage.Add(cameraAnchor);
2246   stage.GetRenderTaskList().GetTask(0).SetCameraActor(freeLookCameraActor);
2247
2248   for(float angle = 1.0f; angle <= 180.0f; angle += 1.0f)
2249   {
2250     Quaternion rotation(Radian(Degree(angle)), Vector3::YAXIS);
2251
2252     freeLookCameraActor.SetProperty(Actor::Property::POSITION, rotation.Rotate(cameraOffset));
2253     cameraAnchor.SetProperty(Actor::Property::ORIENTATION, rotation);
2254
2255     application.SendNotification();
2256     application.Render();
2257     application.SendNotification();
2258     application.Render();
2259
2260     Matrix freeLookViewMatrix;
2261     freeLookCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(freeLookViewMatrix);
2262
2263     Matrix freeLookWorld = freeLookCameraActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
2264
2265     Matrix freeLookTest(false);
2266     Matrix::Multiply(freeLookTest, freeLookViewMatrix, freeLookWorld);
2267     DALI_TEST_EQUALS(freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION);
2268   }
2269   END_TEST;
2270 }
2271
2272 int UtcDaliCameraActorReflectionByPlane(void)
2273 {
2274   TestApplication application;
2275
2276   Integration::Scene stage = application.GetScene();
2277
2278   Vector3 targetPosition(Vector3::ZERO);
2279   Vector3 cameraOffset(0.0f, 100.0f, 100.0f);
2280
2281   CameraActor freeLookCameraActor = stage.GetRenderTaskList().GetTask(0).GetCameraActor();
2282   freeLookCameraActor.SetType(Camera::LOOK_AT_TARGET);
2283   freeLookCameraActor.SetTargetPosition(targetPosition);
2284   freeLookCameraActor.SetProperty(Actor::Property::POSITION, cameraOffset);
2285
2286   stage.GetRootLayer().SetProperty(Actor::Property::POSITION, Vector2(1, 0));
2287
2288   application.SendNotification();
2289   application.Render();
2290   application.SendNotification();
2291   application.Render();
2292
2293   Matrix matrixBefore, matrixAfter;
2294   freeLookCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(matrixBefore);
2295   freeLookCameraActor.SetProperty(Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4(0.0f, 1.0f, 0.0f, 0.0f));
2296   stage.GetRootLayer().SetProperty(Actor::Property::POSITION, Vector2(0, 0));
2297   application.SendNotification();
2298   application.Render();
2299   application.SendNotification();
2300   application.Render();
2301
2302   freeLookCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(matrixAfter);
2303
2304   Vector3    position, scale;
2305   Quaternion rotation;
2306   matrixAfter.GetTransformComponents(position, rotation, scale);
2307
2308   Quaternion reflected(0, 0, 1, 0);
2309
2310   DALI_TEST_EQUALS(reflected, rotation, 0.01f, TEST_LOCATION);
2311
2312   // Test Free Look camera
2313   freeLookCameraActor.SetType(Camera::FREE_LOOK);
2314
2315   // Make sure the recalculation will take place
2316   freeLookCameraActor.SetProperty(Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4(0.0f, 1.0f, 0.0f, 0.0f));
2317
2318   application.SendNotification();
2319   application.Render();
2320   application.SendNotification();
2321   application.Render();
2322
2323   // Nothing should change despite of different camera type
2324   matrixAfter.GetTransformComponents(position, rotation, scale);
2325   DALI_TEST_EQUALS(reflected, rotation, 0.01f, TEST_LOCATION);
2326
2327   // Test Orthographic camera
2328   freeLookCameraActor.SetProjectionMode(Dali::Camera::ProjectionMode::ORTHOGRAPHIC_PROJECTION);
2329
2330   // Make sure the recalculation will take place
2331   freeLookCameraActor.SetProperty(Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4(0.0f, 1.0f, 0.0f, 0.0f));
2332
2333   application.SendNotification();
2334   application.Render();
2335   application.SendNotification();
2336   application.Render();
2337
2338   // Nothing should change despite of different camera type
2339   matrixAfter.GetTransformComponents(position, rotation, scale);
2340   DALI_TEST_EQUALS(reflected, rotation, 0.01f, TEST_LOCATION);
2341
2342   // Test Orthographic camera + Look at target
2343   freeLookCameraActor.SetType(Camera::LOOK_AT_TARGET);
2344   freeLookCameraActor.SetTargetPosition(targetPosition);
2345
2346   // Make sure the recalculation will take place
2347   freeLookCameraActor.SetProperty(Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4(0.0f, 1.0f, 0.0f, 0.0f));
2348
2349   application.SendNotification();
2350   application.Render();
2351   application.SendNotification();
2352   application.Render();
2353
2354   // Nothing should change despite of different camera type
2355   matrixAfter.GetTransformComponents(position, rotation, scale);
2356   DALI_TEST_EQUALS(reflected, rotation, 0.01f, TEST_LOCATION);
2357
2358   END_TEST;
2359 }
2360
2361 int UtcDaliCameraActorProjectionDirection(void)
2362 {
2363   TestApplication application;
2364
2365   Integration::Scene stage     = application.GetScene();
2366   Vector2            stageSize = stage.GetSize();
2367
2368   CameraActor defaultCameraActor = stage.GetRenderTaskList().GetTask(0).GetCameraActor();
2369   CameraActor expectCameraActor1 = CameraActor::New(stageSize);
2370   CameraActor expectCameraActor2 = CameraActor::New(stageSize);
2371   CameraActor expectCameraActor3 = CameraActor::New(stageSize);
2372
2373   float fieldOfView = defaultCameraActor.GetFieldOfView();
2374   float aspectRatio = defaultCameraActor.GetAspectRatio();
2375
2376   // Calculate expect camera 1's fov.
2377   float anotherFieldOfView = 2.0f * std::atan(std::tan(fieldOfView * 0.5f) / aspectRatio);
2378   expectCameraActor1.SetFieldOfView(anotherFieldOfView);
2379
2380   // Calculate expect camera 2's fov and aspect ratio.
2381   float anotherFieldOfView2 = 2.0f * std::atan(std::tan(fieldOfView * 0.5f) * aspectRatio);
2382   float anotherAspectRatio  = 1.0f / aspectRatio;
2383   expectCameraActor2.SetFieldOfView(anotherFieldOfView2);
2384   expectCameraActor2.SetAspectRatio(anotherAspectRatio);
2385
2386   // Calculate expect camera 3's aspect raio
2387   expectCameraActor3.SetAspectRatio(anotherAspectRatio);
2388
2389   stage.Add(expectCameraActor1);
2390   stage.Add(expectCameraActor2);
2391   stage.Add(expectCameraActor3);
2392
2393   application.SendNotification();
2394   application.Render();
2395   application.SendNotification();
2396   application.Render();
2397
2398   // Test default projection direction is VERTICAL
2399   DALI_TEST_EQUALS(defaultCameraActor.GetProperty<int>(Dali::DevelCameraActor::Property::PROJECTION_DIRECTION), static_cast<int>(Dali::DevelCameraActor::ProjectionDirection::VERTICAL), TEST_LOCATION);
2400
2401   Matrix matrixBefore, matrixAfter;
2402   Matrix matrixExpect1, matrixExpect2, matrixExpect3;
2403
2404   defaultCameraActor.GetProperty(CameraActor::CameraActor::Property::PROJECTION_MATRIX).Get(matrixBefore);
2405   expectCameraActor1.GetProperty(CameraActor::CameraActor::Property::PROJECTION_MATRIX).Get(matrixExpect1);
2406   expectCameraActor2.GetProperty(CameraActor::CameraActor::Property::PROJECTION_MATRIX).Get(matrixExpect2);
2407   expectCameraActor3.GetProperty(CameraActor::CameraActor::Property::PROJECTION_MATRIX).Get(matrixExpect3);
2408
2409   tet_printf("Check ProjectionDirection::HORIZONTAL\n");
2410
2411   defaultCameraActor.SetProperty(Dali::DevelCameraActor::Property::PROJECTION_DIRECTION, Dali::DevelCameraActor::ProjectionDirection::HORIZONTAL);
2412   DALI_TEST_EQUALS(defaultCameraActor.GetProperty<int>(Dali::DevelCameraActor::Property::PROJECTION_DIRECTION), static_cast<int>(Dali::DevelCameraActor::ProjectionDirection::HORIZONTAL), TEST_LOCATION);
2413   // NOTE : ProjectionDirection doesn't change camera actor's FieldOfView and AspectRatio value.)
2414   DALI_TEST_EQUALS(defaultCameraActor.GetFieldOfView(), fieldOfView, TEST_LOCATION);
2415   DALI_TEST_EQUALS(defaultCameraActor.GetAspectRatio(), aspectRatio, TEST_LOCATION);
2416
2417   application.SendNotification();
2418   application.Render();
2419   application.SendNotification();
2420   application.Render();
2421
2422   defaultCameraActor.GetProperty(CameraActor::CameraActor::Property::PROJECTION_MATRIX).Get(matrixAfter);
2423
2424   // Check camera's ProjectionMatrix same as expect camera 1's ProjectionMatrix.
2425   DALI_TEST_EQUALS(matrixAfter, matrixExpect1, Dali::Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2426
2427   tet_printf("Check ProjectionDirection::HORIZONTAL + Change aspect ratio\n");
2428
2429   defaultCameraActor.SetAspectRatio(anotherAspectRatio);
2430   DALI_TEST_EQUALS(defaultCameraActor.GetAspectRatio(), anotherAspectRatio, TEST_LOCATION);
2431
2432   application.SendNotification();
2433   application.Render();
2434   application.SendNotification();
2435   application.Render();
2436
2437   defaultCameraActor.GetProperty(CameraActor::CameraActor::Property::PROJECTION_MATRIX).Get(matrixAfter);
2438
2439   // Check camera's ProjectionMatrix same as expect camera 2's ProjectionMatrix.
2440   DALI_TEST_EQUALS(matrixAfter, matrixExpect2, Dali::Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2441
2442   tet_printf("Check ProjectionDirection::HORIZONTAL + Change aspect ratio + Change fov\n");
2443
2444   defaultCameraActor.SetFieldOfView(anotherFieldOfView);
2445   DALI_TEST_EQUALS(defaultCameraActor.GetFieldOfView(), anotherFieldOfView, TEST_LOCATION);
2446   DALI_TEST_EQUALS(defaultCameraActor.GetAspectRatio(), anotherAspectRatio, TEST_LOCATION);
2447
2448   application.SendNotification();
2449   application.Render();
2450   application.SendNotification();
2451   application.Render();
2452
2453   defaultCameraActor.GetProperty(CameraActor::CameraActor::Property::PROJECTION_MATRIX).Get(matrixAfter);
2454
2455   // Check camera's ProjectionMatrix same as expect camera 3's ProjectionMatrix.
2456   DALI_TEST_EQUALS(matrixAfter, matrixExpect3, Dali::Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2457
2458   tet_printf("Check ProjectionDirection::VERTICAL, the original camera\n");
2459
2460   defaultCameraActor.SetProperty(Dali::DevelCameraActor::Property::PROJECTION_DIRECTION, Dali::DevelCameraActor::ProjectionDirection::VERTICAL);
2461   defaultCameraActor.SetFieldOfView(fieldOfView);
2462   defaultCameraActor.SetAspectRatio(aspectRatio);
2463   DALI_TEST_EQUALS(defaultCameraActor.GetProperty<int>(Dali::DevelCameraActor::Property::PROJECTION_DIRECTION), static_cast<int>(Dali::DevelCameraActor::ProjectionDirection::VERTICAL), TEST_LOCATION);
2464   DALI_TEST_EQUALS(defaultCameraActor.GetFieldOfView(), fieldOfView, TEST_LOCATION);
2465   DALI_TEST_EQUALS(defaultCameraActor.GetAspectRatio(), aspectRatio, TEST_LOCATION);
2466
2467   application.SendNotification();
2468   application.Render();
2469   application.SendNotification();
2470   application.Render();
2471
2472   defaultCameraActor.GetProperty(CameraActor::CameraActor::Property::PROJECTION_MATRIX).Get(matrixAfter);
2473
2474   // Check vertical camera's ProjectionMatrix same as original ProjectionMatrix.
2475   DALI_TEST_EQUALS(matrixAfter, matrixBefore, Dali::Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2476
2477   END_TEST;
2478 }
2479
2480 int UtcDaliCameraActorGetAspectRatioNegative(void)
2481 {
2482   TestApplication   application;
2483   Dali::CameraActor instance;
2484   try
2485   {
2486     instance.GetAspectRatio();
2487     DALI_TEST_CHECK(false); // Should not get here
2488   }
2489   catch(...)
2490   {
2491     DALI_TEST_CHECK(true); // We expect an assert
2492   }
2493   END_TEST;
2494 }
2495
2496 int UtcDaliCameraActorGetFieldOfViewNegative(void)
2497 {
2498   TestApplication   application;
2499   Dali::CameraActor instance;
2500   try
2501   {
2502     instance.GetFieldOfView();
2503     DALI_TEST_CHECK(false); // Should not get here
2504   }
2505   catch(...)
2506   {
2507     DALI_TEST_CHECK(true); // We expect an assert
2508   }
2509   END_TEST;
2510 }
2511
2512 int UtcDaliCameraActorGetInvertYAxisNegative(void)
2513 {
2514   TestApplication   application;
2515   Dali::CameraActor instance;
2516   try
2517   {
2518     instance.GetInvertYAxis();
2519     DALI_TEST_CHECK(false); // Should not get here
2520   }
2521   catch(...)
2522   {
2523     DALI_TEST_CHECK(true); // We expect an assert
2524   }
2525   END_TEST;
2526 }
2527
2528 int UtcDaliCameraActorSetAspectRatioNegative(void)
2529 {
2530   TestApplication   application;
2531   Dali::CameraActor instance;
2532   try
2533   {
2534     float arg1(0.0f);
2535     instance.SetAspectRatio(arg1);
2536     DALI_TEST_CHECK(false); // Should not get here
2537   }
2538   catch(...)
2539   {
2540     DALI_TEST_CHECK(true); // We expect an assert
2541   }
2542   END_TEST;
2543 }
2544
2545 int UtcDaliCameraActorSetFieldOfViewNegative(void)
2546 {
2547   TestApplication   application;
2548   Dali::CameraActor instance;
2549   try
2550   {
2551     float arg1(0.0f);
2552     instance.SetFieldOfView(arg1);
2553     DALI_TEST_CHECK(false); // Should not get here
2554   }
2555   catch(...)
2556   {
2557     DALI_TEST_CHECK(true); // We expect an assert
2558   }
2559   END_TEST;
2560 }
2561
2562 int UtcDaliCameraActorSetInvertYAxisNegative(void)
2563 {
2564   TestApplication   application;
2565   Dali::CameraActor instance;
2566   try
2567   {
2568     bool arg1(false);
2569     instance.SetInvertYAxis(arg1);
2570     DALI_TEST_CHECK(false); // Should not get here
2571   }
2572   catch(...)
2573   {
2574     DALI_TEST_CHECK(true); // We expect an assert
2575   }
2576   END_TEST;
2577 }
2578
2579 int UtcDaliCameraActorSetProjectionModeNegative(void)
2580 {
2581   TestApplication   application;
2582   Dali::CameraActor instance;
2583   try
2584   {
2585     Dali::Camera::ProjectionMode arg1(Camera::PERSPECTIVE_PROJECTION);
2586     instance.SetProjectionMode(arg1);
2587     DALI_TEST_CHECK(false); // Should not get here
2588   }
2589   catch(...)
2590   {
2591     DALI_TEST_CHECK(true); // We expect an assert
2592   }
2593   END_TEST;
2594 }
2595
2596 int UtcDaliCameraActorSetTargetPositionNegative(void)
2597 {
2598   TestApplication   application;
2599   Dali::CameraActor instance;
2600   try
2601   {
2602     Dali::Vector3 arg1;
2603     instance.SetTargetPosition(arg1);
2604     DALI_TEST_CHECK(false); // Should not get here
2605   }
2606   catch(...)
2607   {
2608     DALI_TEST_CHECK(true); // We expect an assert
2609   }
2610   END_TEST;
2611 }
2612
2613 int UtcDaliCameraActorGetFarClippingPlaneNegative(void)
2614 {
2615   TestApplication   application;
2616   Dali::CameraActor instance;
2617   try
2618   {
2619     instance.GetFarClippingPlane();
2620     DALI_TEST_CHECK(false); // Should not get here
2621   }
2622   catch(...)
2623   {
2624     DALI_TEST_CHECK(true); // We expect an assert
2625   }
2626   END_TEST;
2627 }
2628
2629 int UtcDaliCameraActorSetFarClippingPlaneNegative(void)
2630 {
2631   TestApplication   application;
2632   Dali::CameraActor instance;
2633   try
2634   {
2635     float arg1(0.0f);
2636     instance.SetFarClippingPlane(arg1);
2637     DALI_TEST_CHECK(false); // Should not get here
2638   }
2639   catch(...)
2640   {
2641     DALI_TEST_CHECK(true); // We expect an assert
2642   }
2643   END_TEST;
2644 }
2645
2646 int UtcDaliCameraActorGetNearClippingPlaneNegative(void)
2647 {
2648   TestApplication   application;
2649   Dali::CameraActor instance;
2650   try
2651   {
2652     instance.GetNearClippingPlane();
2653     DALI_TEST_CHECK(false); // Should not get here
2654   }
2655   catch(...)
2656   {
2657     DALI_TEST_CHECK(true); // We expect an assert
2658   }
2659   END_TEST;
2660 }
2661
2662 int UtcDaliCameraActorSetNearClippingPlaneNegative(void)
2663 {
2664   TestApplication   application;
2665   Dali::CameraActor instance;
2666   try
2667   {
2668     float arg1(0.0f);
2669     instance.SetNearClippingPlane(arg1);
2670     DALI_TEST_CHECK(false); // Should not get here
2671   }
2672   catch(...)
2673   {
2674     DALI_TEST_CHECK(true); // We expect an assert
2675   }
2676   END_TEST;
2677 }
2678
2679 int UtcDaliCameraActorSetPerspectiveProjectionNegative(void)
2680 {
2681   TestApplication   application;
2682   Dali::CameraActor instance;
2683   try
2684   {
2685     Dali::Vector2 arg1;
2686     instance.SetPerspectiveProjection(arg1);
2687     DALI_TEST_CHECK(false); // Should not get here
2688   }
2689   catch(...)
2690   {
2691     DALI_TEST_CHECK(true); // We expect an assert
2692   }
2693   END_TEST;
2694 }
2695
2696 int UtcDaliCameraActorSetOrthographicProjectionNegative02(void)
2697 {
2698   TestApplication   application;
2699   Dali::CameraActor instance;
2700   try
2701   {
2702     Dali::Vector2 arg1;
2703     instance.SetOrthographicProjection(arg1);
2704     DALI_TEST_CHECK(false); // Should not get here
2705   }
2706   catch(...)
2707   {
2708     DALI_TEST_CHECK(true); // We expect an assert
2709   }
2710   END_TEST;
2711 }
2712
2713 int UtcDaliCameraActorSetTypeNegative(void)
2714 {
2715   TestApplication   application;
2716   Dali::CameraActor instance;
2717   try
2718   {
2719     Dali::Camera::Type arg1(Camera::FREE_LOOK);
2720     instance.SetType(arg1);
2721     DALI_TEST_CHECK(false); // Should not get here
2722   }
2723   catch(...)
2724   {
2725     DALI_TEST_CHECK(true); // We expect an assert
2726   }
2727   END_TEST;
2728 }
2729
2730 int UtcDaliCameraActorGetProjectionModeNegative(void)
2731 {
2732   TestApplication   application;
2733   Dali::CameraActor instance;
2734   try
2735   {
2736     instance.GetProjectionMode();
2737     DALI_TEST_CHECK(false); // Should not get here
2738   }
2739   catch(...)
2740   {
2741     DALI_TEST_CHECK(true); // We expect an assert
2742   }
2743   END_TEST;
2744 }
2745
2746 int UtcDaliCameraActorGetTargetPositionNegative(void)
2747 {
2748   TestApplication   application;
2749   Dali::CameraActor instance;
2750   try
2751   {
2752     instance.GetTargetPosition();
2753     DALI_TEST_CHECK(false); // Should not get here
2754   }
2755   catch(...)
2756   {
2757     DALI_TEST_CHECK(true); // We expect an assert
2758   }
2759   END_TEST;
2760 }
2761
2762 int UtcDaliCameraActorGetTypeNegative(void)
2763 {
2764   TestApplication   application;
2765   Dali::CameraActor instance;
2766   try
2767   {
2768     instance.GetType();
2769     DALI_TEST_CHECK(false); // Should not get here
2770   }
2771   catch(...)
2772   {
2773     DALI_TEST_CHECK(true); // We expect an assert
2774   }
2775   END_TEST;
2776 }
2777
2778 int UtcDaliCameraActorNewDefaultOrthogonalProjection01(void)
2779 {
2780   TestApplication application;
2781   tet_infoline("Test that changing to orthogonal projection and then adding to scene calculates the right defaults");
2782
2783   CameraActor actor = CameraActor::New();
2784   DALI_TEST_CHECK(actor);
2785
2786   actor.SetProjectionMode(Camera::ORTHOGRAPHIC_PROJECTION);
2787   application.GetScene().Add(actor);
2788
2789   // Test application screen size is 480x800
2790   // Check that the properties match to that screen size
2791   float value;
2792   actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
2793   DALI_TEST_EQUALS(480.0f / 800.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2794
2795   actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
2796   DALI_TEST_EQUALS(800.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2797
2798   actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
2799   DALI_TEST_EQUALS(4895.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2800
2801   actor.GetProperty(CameraActor::Property::LEFT_PLANE_DISTANCE).Get(value);
2802   DALI_TEST_EQUALS(-240.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2803   actor.GetProperty(CameraActor::Property::RIGHT_PLANE_DISTANCE).Get(value);
2804   DALI_TEST_EQUALS(240.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2805
2806   actor.GetProperty(CameraActor::Property::TOP_PLANE_DISTANCE).Get(value);
2807   DALI_TEST_EQUALS(400.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2808   actor.GetProperty(CameraActor::Property::BOTTOM_PLANE_DISTANCE).Get(value);
2809   DALI_TEST_EQUALS(-400.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2810
2811   DALI_TEST_EQUALS(1600.0f, actor.GetProperty(Actor::Property::POSITION_Z).Get<float>(), TEST_LOCATION);
2812
2813   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
2814   END_TEST;
2815 }
2816
2817 int UtcDaliCameraActorNewDefaultOrthogonalProjection02(void)
2818 {
2819   TestApplication application;
2820   tet_infoline("Test that changing to orthogonal projection and then adding to scene calculates the right defaults");
2821
2822   CameraActor actor = CameraActor::New();
2823   DALI_TEST_CHECK(actor);
2824
2825   actor.SetOrthographicProjection(Vector2::ZERO);
2826   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
2827   application.GetScene().Add(actor);
2828
2829   // Test application screen size is 480x800
2830   // Check that the properties match to that screen size
2831   float value;
2832   actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
2833   DALI_TEST_EQUALS(480.0f / 800.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2834
2835   actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
2836   DALI_TEST_EQUALS(800.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2837
2838   actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
2839   DALI_TEST_EQUALS(4895.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2840
2841   actor.GetProperty(CameraActor::Property::LEFT_PLANE_DISTANCE).Get(value);
2842   DALI_TEST_EQUALS(-240.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2843   actor.GetProperty(CameraActor::Property::RIGHT_PLANE_DISTANCE).Get(value);
2844   DALI_TEST_EQUALS(240.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2845
2846   actor.GetProperty(CameraActor::Property::TOP_PLANE_DISTANCE).Get(value);
2847   DALI_TEST_EQUALS(400.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2848   actor.GetProperty(CameraActor::Property::BOTTOM_PLANE_DISTANCE).Get(value);
2849   DALI_TEST_EQUALS(-400.0f, value, FLOAT_EPSILON, TEST_LOCATION);
2850
2851   DALI_TEST_EQUALS(1600.0f, actor.GetProperty(Actor::Property::POSITION_Z).Get<float>(), TEST_LOCATION);
2852
2853   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
2854   END_TEST;
2855 }
2856
2857 // Add tests for culling:
2858 //   add large actor just outside canvas, & rotate it 45% - should still be rendered
2859 //   Rotate back to 0, should be culled.
2860
2861 int UtcDaliCameraActorCulling01(void)
2862 {
2863   TestApplication application;
2864   auto&           gfx = application.GetGraphicsController();
2865
2866   tet_infoline("Create a renderable actor and position it slightly to the left of the scene");
2867   tet_infoline("The actor should not be rendered");
2868
2869   Actor a = CreateRenderableActor(CreateTexture(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 200, 200));
2870
2871   a[Actor::Property::PARENT_ORIGIN] = ParentOrigin::CENTER_LEFT;
2872   a[Actor::Property::ANCHOR_POINT]  = ParentOrigin::CENTER_RIGHT;
2873   a[Actor::Property::POSITION]      = Vector3(-10.0f, 0.0f, 0.0f);
2874
2875   application.GetScene().Add(a);
2876
2877   application.SendNotification();
2878   application.Render();
2879
2880   auto& cmdStack = gfx.mCommandBufferCallStack;
2881   DALI_TEST_CHECK(!cmdStack.FindMethod("Draw") && !cmdStack.FindMethod("DrawIndexed"));
2882
2883   tet_infoline("Rotate the actor 45 degrees, the actor should now be rendered");
2884   a[Actor::Property::ORIENTATION] = Quaternion(Dali::ANGLE_45, Vector3::ZAXIS);
2885   application.SendNotification();
2886   application.Render();
2887
2888   DALI_TEST_CHECK(cmdStack.FindMethod("Draw") || cmdStack.FindMethod("DrawIndexed"));
2889
2890   END_TEST;
2891 }
2892
2893 int UtcDaliCameraActorSetProperty(void)
2894 {
2895   TestApplication application;
2896
2897   tet_infoline("Test the CameraActor reset properties when On Scene, if user set property explicitly.");
2898
2899   CameraActor camera = CameraActor::New();
2900   camera.SetFieldOfView(1.0f);
2901   application.GetScene().Add(camera);
2902   DALI_TEST_EQUALS(1.0f, camera.GetFieldOfView(), TEST_LOCATION);
2903   camera.Unparent();
2904   camera.Reset();
2905
2906   camera = CameraActor::New();
2907   camera.SetAspectRatio(1.0f);
2908   application.GetScene().Add(camera);
2909   DALI_TEST_EQUALS(1.0f, camera.GetAspectRatio(), TEST_LOCATION);
2910   camera.Unparent();
2911   camera.Reset();
2912
2913   camera = CameraActor::New();
2914   camera.SetNearClippingPlane(1.0f);
2915   application.GetScene().Add(camera);
2916   DALI_TEST_EQUALS(1.0f, camera.GetNearClippingPlane(), TEST_LOCATION);
2917   camera.Unparent();
2918   camera.Reset();
2919
2920   camera = CameraActor::New();
2921   camera.SetFarClippingPlane(1.0f);
2922   application.GetScene().Add(camera);
2923   DALI_TEST_EQUALS(1.0f, camera.GetFarClippingPlane(), TEST_LOCATION);
2924   camera.Unparent();
2925   camera.Reset();
2926
2927   camera = CameraActor::New();
2928   camera.SetProperty(Dali::Actor::Property::POSITION, Vector3(100.0f, 100.0f, 100.0f));
2929   application.GetScene().Add(camera);
2930   DALI_TEST_EQUALS(Vector3(100.0f, 100.0f, 100.0f), camera.GetProperty<Vector3>(Dali::Actor::Property::POSITION), TEST_LOCATION);
2931   camera.Unparent();
2932   camera.Reset();
2933
2934   camera = CameraActor::New();
2935   camera.SetProperty(Dali::Actor::Property::POSITION_X, 1.0f);
2936   application.GetScene().Add(camera);
2937   DALI_TEST_EQUALS(1.0f, camera.GetProperty<float>(Dali::Actor::Property::POSITION_X), TEST_LOCATION);
2938   camera.Unparent();
2939   camera.Reset();
2940
2941   camera = CameraActor::New();
2942   camera.SetProperty(Dali::Actor::Property::POSITION_Y, 1.0f);
2943   application.GetScene().Add(camera);
2944   DALI_TEST_EQUALS(1.0f, camera.GetProperty<float>(Dali::Actor::Property::POSITION_Y), TEST_LOCATION);
2945   camera.Unparent();
2946   camera.Reset();
2947
2948   camera = CameraActor::New();
2949   camera.SetProperty(Dali::Actor::Property::POSITION_Z, 1.0f);
2950   application.GetScene().Add(camera);
2951   DALI_TEST_EQUALS(1.0f, camera.GetProperty<float>(Dali::Actor::Property::POSITION_Z), TEST_LOCATION);
2952   camera.Unparent();
2953   camera.Reset();
2954
2955   camera = CameraActor::New();
2956   camera.SetProperty(Dali::Actor::Property::ORIENTATION, Quaternion(Radian(Degree(90.0f)), Vector3::XAXIS));
2957   application.GetScene().Add(camera);
2958   DALI_TEST_EQUALS(Quaternion(Radian(Degree(90.0f)), Vector3::XAXIS), camera.GetProperty<Quaternion>(Dali::Actor::Property::ORIENTATION), TEST_LOCATION);
2959   camera.Unparent();
2960   camera.Reset();
2961
2962   END_TEST;
2963 }