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