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