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

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