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

   1 /*
   2  * Copyright (c) 2020 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 <iostream>
  19
  20 #include <stdlib.h>
  21 #include <cmath>
  22 #include <dali/public-api/dali-core.h>
  23 #include <dali/devel-api/actors/actor-devel.h>
  24 #include <dali/devel-api/actors/camera-actor-devel.h>
  25
  26 #include "dali-test-suite-utils/dali-test-suite-utils.h"
  27
  28 using namespace Dali;
  29
  30 void camera_actor_test_startup(void)
  31 {
  32   test_return_value = TET_UNDEF;
  33 }
  34
  35 void camera_actor_test_cleanup(void)
  36 {
  37   test_return_value = TET_PASS;
  38 }
  39
  40 namespace
  41 {
  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
  84 int UtcDaliCameraActorConstructorP(void)
  85 {
  86   TestApplication application;
  87   tet_infoline( "Testing Dali::CameraActor::CameraActor()" );
  88
  89   CameraActor actor;
  90
  91   DALI_TEST_CHECK( !actor );
  92   END_TEST;
  93 }
  94
  95 // Note: No negative test for UtcDaliCameraActorConstructor.
  96
  97 int UtcDaliCameraActorDestructorP(void)
  98 {
  99   TestApplication application;
 100   tet_infoline( "Testing Dali::~CameraActor (P)" );
 101   CameraActor* actor = new CameraActor();
 102   delete actor;
 103   actor = NULL;
 104
 105   DALI_TEST_CHECK( true );
 106   END_TEST;
 107 }
 108
 109 // Note: No negative test for UtcDaliCameraActorDestructor.
 110
 111 int UtcDaliCameraActorCopyConstructorP(void)
 112 {
 113   TestApplication application;
 114   tet_infoline( "Testing Dali::CameraActor Copy Constructor (P)" );
 115   CameraActor actor = CameraActor::New();
 116
 117   CameraActor copyActor( actor );
 118
 119   DALI_TEST_CHECK( copyActor );
 120   DALI_TEST_CHECK( copyActor == actor );
 121
 122   END_TEST;
 123 }
 124
 125 int UtcDaliCameraActorCopyConstructorN(void)
 126 {
 127   TestApplication application;
 128   tet_infoline( "Testing Dali::CameraActor Copy Constructor (N)" );
 129   CameraActor actor;
 130
 131   CameraActor copyActor( actor );
 132
 133   DALI_TEST_CHECK( !copyActor );
 134
 135   END_TEST;
 136 }
 137
 138 int UtcDaliCameraActorAssignmentOperatorP(void)
 139 {
 140   TestApplication application;
 141   tet_infoline( "Testing Dali::CameraActor Assignment Operator (P)" );
 142   const CameraActor actor = CameraActor::New();
 143
 144   CameraActor copyActor = actor;
 145
 146   DALI_TEST_CHECK( copyActor );
 147   DALI_TEST_CHECK( copyActor == actor );
 148
 149   END_TEST;
 150 }
 151
 152 int UtcDaliCameraActorAssignmentOperatorN(void)
 153 {
 154   TestApplication application;
 155   tet_infoline( "Testing Dali::CameraActor = (N)" );
 156   CameraActor actor;
 157
 158   CameraActor copyActor = actor;
 159
 160   DALI_TEST_CHECK( !copyActor );
 161
 162   END_TEST;
 163 }
 164
 165 int UtcDaliCameraActorNewP(void)
 166 {
 167   TestApplication application;
 168   tet_infoline( "Testing Dali::CameraActor::New (P)" );
 169
 170   CameraActor actor = CameraActor::New();
 171
 172   DALI_TEST_CHECK( actor );
 173
 174   actor.Reset();
 175
 176   DALI_TEST_CHECK( !actor );
 177   END_TEST;
 178 }
 179
 180 int UtcDaliCameraActorNewDefaultPerspectiveProjection(void)
 181 {
 182   TestApplication application;
 183   tet_infoline( "Test the perspective projection of a camera actor is set appropriately when not passing in a size" );
 184
 185   CameraActor actor = CameraActor::New();
 186   DALI_TEST_CHECK( actor );
 187
 188   // All the properties should still be the default values
 189   // Defaults taken from scene-graph-camera.cpp
 190   DALI_TEST_EQUALS( 4.0f/3.0f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 191   DALI_TEST_EQUALS( 45.0f*(Math::PI/180.0f), actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 192   DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 193   DALI_TEST_EQUALS( 3.0f * 800.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 194   DALI_TEST_EQUALS( 0.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
 195   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
 196
 197   // Add it to the stage, then the values should be updated to reflect a 480.0f by 800.0f scene (default stage size)
 198   application.GetScene().Add( actor );
 199
 200   DALI_TEST_EQUALS( 0.6f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 201   DALI_TEST_EQUALS( 0.489957f, actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 202   DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 203   DALI_TEST_EQUALS( 4895.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 204   DALI_TEST_EQUALS( 1600.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
 205   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
 206
 207   // Ensure the values stay the same after update/render
 208   application.SendNotification();
 209   application.Render();
 210
 211   DALI_TEST_EQUALS( 0.6f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 212   DALI_TEST_EQUALS( 0.489957f, actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 213   DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 214   DALI_TEST_EQUALS( 4895.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 215   DALI_TEST_EQUALS( 1600.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
 216   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
 217
 218   END_TEST;
 219 }
 220
 221 // Note: No negative test for UtcDaliCameraActorNew.
 222
 223 int UtcDaliCameraActorDownCastP(void)
 224 {
 225   TestApplication application;
 226   tet_infoline( "Testing Dali::CameraActor::DownCast (P)" );
 227
 228   CameraActor camera = CameraActor::New();
 229   Actor anActor = Actor::New();
 230   anActor.Add( camera );
 231
 232   Actor child = anActor.GetChildAt( 0 );
 233   CameraActor cameraActor = CameraActor::DownCast( child );
 234   DALI_TEST_CHECK( cameraActor );
 235
 236   cameraActor.Reset();
 237   DALI_TEST_CHECK( !cameraActor );
 238
 239   cameraActor = DownCast< CameraActor >( child );
 240   DALI_TEST_CHECK( cameraActor );
 241   END_TEST;
 242 }
 243
 244 int UtcDaliCameraActorDownCastN(void)
 245 {
 246   TestApplication application;
 247   tet_infoline( "Testing Dali::CameraActor::DownCast (N)" );
 248
 249   Actor actor1 = Actor::New();
 250   Actor anActor = Actor::New();
 251   anActor.Add( actor1 );
 252
 253   Actor child = anActor.GetChildAt( 0 );
 254   CameraActor cameraActor = CameraActor::DownCast( child );
 255   DALI_TEST_CHECK( !cameraActor );
 256
 257   Actor unInitialzedActor;
 258   cameraActor = CameraActor::DownCast( unInitialzedActor );
 259   DALI_TEST_CHECK( !cameraActor );
 260
 261   cameraActor = DownCast< CameraActor >( unInitialzedActor );
 262   DALI_TEST_CHECK( !cameraActor );
 263   END_TEST;
 264 }
 265
 266 // Note: SetType and GetType are tested within the same test cases.
 267
 268 int UtcDaliCameraActorSetGetTypeP(void)
 269 {
 270   TestApplication application;
 271   tet_infoline( "Testing Dali::CameraActor GetType (P)" );
 272
 273   CameraActor actor = CameraActor::New();
 274   DALI_TEST_EQUALS( actor.GetType(), Dali::Camera::FREE_LOOK, TEST_LOCATION );
 275
 276   actor.SetType( Dali::Camera::LOOK_AT_TARGET );
 277   DALI_TEST_EQUALS( actor.GetType(), Dali::Camera::LOOK_AT_TARGET, TEST_LOCATION );
 278
 279   DALI_TEST_EQUALS( "LOOK_AT_TARGET", actor.GetProperty< std::string >( CameraActor::Property::TYPE ), TEST_LOCATION );
 280   DALI_TEST_EQUALS( "LOOK_AT_TARGET", actor.GetCurrentProperty< std::string >( CameraActor::Property::TYPE ), TEST_LOCATION );
 281   END_TEST;
 282 }
 283
 284 int UtcDaliCameraActorSetGetTypeN(void)
 285 {
 286   TestApplication application;
 287   tet_infoline( "Testing Dali::CameraActor GetType (N)" );
 288
 289   CameraActor actor;
 290
 291   Dali::Camera::Type cameraType = Dali::Camera::FREE_LOOK;
 292   try
 293   {
 294     cameraType = actor.GetType();
 295   }
 296   catch ( Dali::DaliException& e )
 297   {
 298     DALI_TEST_PRINT_ASSERT( e );
 299     DALI_TEST_ASSERT( e, "camera", TEST_LOCATION );
 300   }
 301
 302   const CameraActor aConstActor;
 303
 304   try
 305   {
 306     cameraType = aConstActor.GetType();
 307   }
 308   catch ( Dali::DaliException& e )
 309   {
 310     DALI_TEST_PRINT_ASSERT( e );
 311     DALI_TEST_ASSERT( e, "camera", TEST_LOCATION );
 312   }
 313
 314   DALI_TEST_EQUALS( cameraType, Dali::Camera::FREE_LOOK, TEST_LOCATION );
 315   END_TEST;
 316 }
 317
 318 int UtcDaliCameraActorSetFieldOfViewP(void)
 319 {
 320   TestApplication application;
 321   tet_infoline( "Testing Dali::CameraActor Set Field of view (P)" );
 322
 323   CameraActor defaultCamera = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 324   const float defaultFieldOfView = defaultCamera.GetFieldOfView();
 325
 326   CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 327   DALI_TEST_EQUALS( actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION );
 328
 329   float fieldOfView = Math::PI / 3.0f;
 330   actor.SetFieldOfView( fieldOfView );
 331   DALI_TEST_EQUALS( actor.GetFieldOfView(), fieldOfView, TEST_LOCATION );
 332
 333   float value;
 334   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 335   DALI_TEST_EQUALS( fieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 336   END_TEST;
 337 }
 338
 339 int UtcDaliCameraActorSetFieldOfViewN(void)
 340 {
 341   TestApplication application;
 342   tet_infoline( "Testing Dali::CameraActor Set Field of view (N)" );
 343
 344   CameraActor defaultCamera = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 345   const float defaultFieldOfView = defaultCamera.GetFieldOfView();
 346
 347   CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 348   DALI_TEST_EQUALS( actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION );
 349
 350   float fieldOfView = Math::PI / 3.0f;
 351   actor.SetFieldOfView( fieldOfView );
 352   DALI_TEST_EQUALS( actor.GetFieldOfView(), fieldOfView, TEST_LOCATION );
 353
 354   float value;
 355   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 356   DALI_TEST_EQUALS( fieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 357   END_TEST;
 358 }
 359
 360 int UtcDaliCameraActorGetFieldOfViewP(void)
 361 {
 362   TestApplication application;
 363   tet_infoline( "Testing Dali::CameraActor Get Field of view (P)" );
 364   const Vector2 size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
 365
 366   CameraActor defaultCamera = CameraActor::New( size );
 367
 368   const float cameraZ = 2.0f * std::max( size.width, size.height );
 369   const float expectedFieldOfView = 2.0f * std::atan( size.height * 0.5f / cameraZ );
 370
 371   CameraActor actor = CameraActor::New( size );
 372   DALI_TEST_EQUALS( actor.GetFieldOfView(), expectedFieldOfView, TEST_LOCATION );
 373
 374   float value;
 375   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 376   DALI_TEST_EQUALS( expectedFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
 377   END_TEST;
 378 }
 379
 380 int UtcDaliCameraActorGetFieldOfViewN(void)
 381 {
 382   TestApplication application;
 383   tet_infoline( "Testing Dali::CameraActor Get Field of view (N)" );
 384
 385   CameraActor defaultCamera = CameraActor::New();
 386
 387   bool asserted = true;
 388   try
 389   {
 390     defaultCamera.GetFieldOfView();
 391   }
 392   catch( Dali::DaliException& e )
 393   {
 394     DALI_TEST_PRINT_ASSERT( e );
 395     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 396     asserted = true;
 397   }
 398   DALI_TEST_CHECK( asserted );
 399
 400   END_TEST;
 401 }
 402
 403 int UtcDaliCameraActorSetAspectRatioP(void)
 404 {
 405   TestApplication application;
 406   tet_infoline( "Testing Dali::CameraActor Set Aspect Ratio (P)" );
 407
 408   CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 409   DALI_TEST_EQUALS( actor.GetAspectRatio(), static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ) / static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT ), TEST_LOCATION );
 410
 411   // Set an initial value to confirm a further set changes it.
 412   float aspect = 4.0f / 3.0f;
 413   actor.SetAspectRatio( aspect );
 414   DALI_TEST_EQUALS( actor.GetAspectRatio(), aspect, TEST_LOCATION );
 415
 416   aspect = 16.0f / 9.0f;
 417   actor.SetAspectRatio( aspect );
 418   DALI_TEST_EQUALS( actor.GetAspectRatio(), aspect, TEST_LOCATION );
 419
 420   END_TEST;
 421 }
 422
 423 int UtcDaliCameraActorSetAspectRatioN(void)
 424 {
 425   TestApplication application;
 426   tet_infoline( "Testing Dali::CameraActor Set Aspect Ratio (N)" );
 427
 428   CameraActor actor;
 429
 430   bool asserted = true;
 431   try
 432   {
 433     actor.SetAspectRatio( 16.0f / 9.0f );
 434   }
 435   catch( Dali::DaliException& e )
 436   {
 437     DALI_TEST_PRINT_ASSERT( e );
 438     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 439     asserted = true;
 440   }
 441   DALI_TEST_CHECK( asserted );
 442
 443   END_TEST;
 444 }
 445
 446 int UtcDaliCameraActorGetAspectRatioP(void)
 447 {
 448   TestApplication application;
 449   tet_infoline("Testing Dali::CameraActor Get Aspect Ratio");
 450
 451   CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 452   float defaultAspect = static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ) / static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT );
 453
 454   DALI_TEST_EQUALS( actor.GetAspectRatio(), defaultAspect, TEST_LOCATION );
 455
 456   float value = 0.0f;
 457   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 458   DALI_TEST_EQUALS( defaultAspect, value, FLOAT_EPSILON, TEST_LOCATION );
 459
 460   END_TEST;
 461 }
 462
 463 int UtcDaliCameraActorGetAspectRatioN(void)
 464 {
 465   TestApplication application;
 466   tet_infoline( "Testing Dali::CameraActor Get Aspect Ratio (N)" );
 467
 468   CameraActor actor;
 469
 470   bool asserted = true;
 471   try
 472   {
 473     actor.GetAspectRatio();
 474   }
 475   catch( Dali::DaliException& e )
 476   {
 477     DALI_TEST_PRINT_ASSERT( e );
 478     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 479     asserted = true;
 480   }
 481
 482   DALI_TEST_CHECK( asserted );
 483
 484   END_TEST;
 485 }
 486
 487 int UtcDaliCameraActorSetNearClippingPlaneP(void)
 488 {
 489   TestApplication application;
 490   tet_infoline( "Testing Dali::CameraActor Set Near clipping plane (P)" );
 491
 492   CameraActor actor = CameraActor::New();
 493
 494   // Set a value so we are not relying on a particular default for this test case.
 495   actor.SetNearClippingPlane( 200.0f );
 496   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, TEST_LOCATION );
 497
 498   actor.SetNearClippingPlane( 400.0f );
 499   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 400.0f, TEST_LOCATION );
 500
 501   // Check setting the property.
 502   actor.SetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE, Property::Value( 300.0f ) );
 503   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 300.0f, FLOAT_EPSILON, TEST_LOCATION );
 504   END_TEST;
 505 }
 506
 507 int UtcDaliCameraActorSetNearClippingPlaneN(void)
 508 {
 509   TestApplication application;
 510   tet_infoline( "Testing Dali::CameraActor Set Near clipping plane (N)" );
 511
 512   CameraActor actor;
 513
 514   bool asserted = true;
 515   try
 516   {
 517     actor.SetNearClippingPlane( 200.0f );
 518   }
 519   catch( Dali::DaliException& e )
 520   {
 521     DALI_TEST_PRINT_ASSERT( e );
 522     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 523     asserted = true;
 524   }
 525
 526   DALI_TEST_CHECK( asserted );
 527
 528   END_TEST;
 529 }
 530
 531 int UtcDaliCameraActorGetNearClippingPlaneP(void)
 532 {
 533   TestApplication application;
 534   tet_infoline( "Testing Dali::CameraActor Get Near clipping plane (P)" );
 535
 536   // Check the default value.
 537   CameraActor actor = CameraActor::New();
 538   float defaultValue = 800.0f;
 539   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), defaultValue, TEST_LOCATION );
 540
 541   // Check getting the property.
 542   float value;
 543   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 544   DALI_TEST_EQUALS( defaultValue, value, FLOAT_EPSILON, TEST_LOCATION );
 545   END_TEST;
 546 }
 547
 548 int UtcDaliCameraActorGetNearClippingPlaneN(void)
 549 {
 550   TestApplication application;
 551   tet_infoline( "Testing Dali::CameraActor Get Near clipping plane (N)" );
 552
 553   CameraActor actor;
 554   bool asserted = true;
 555   try
 556   {
 557     actor.GetNearClippingPlane();
 558   }
 559   catch( Dali::DaliException& e )
 560   {
 561     DALI_TEST_PRINT_ASSERT( e );
 562     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 563     asserted = true;
 564   }
 565
 566   DALI_TEST_CHECK( asserted );
 567
 568   END_TEST;
 569 }
 570
 571 int UtcDaliCameraActorSetFarClippingPlaneP(void)
 572 {
 573   TestApplication application;
 574   tet_infoline( "Testing Dali::CameraActor Set Far clipping plane (P)" );
 575
 576   CameraActor actor = CameraActor::New();
 577
 578   // Set a value so we are not relying on a particular default for this test case.
 579   actor.SetFarClippingPlane( 2000.0f );
 580   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 2000.0f, TEST_LOCATION );
 581
 582   actor.SetFarClippingPlane( 4000.0f );
 583   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 4000.0f, TEST_LOCATION );
 584
 585   // Check setting the property.
 586   actor.SetProperty( CameraActor::Property::FAR_PLANE_DISTANCE, 2000.0f );
 587   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 2000.0f, FLOAT_EPSILON, TEST_LOCATION );
 588   END_TEST;
 589 }
 590
 591 int UtcDaliCameraActorSetFarClippingPlaneN(void)
 592 {
 593   TestApplication application;
 594   tet_infoline( "Testing Dali::CameraActor Set Far clipping plane (N)" );
 595
 596   CameraActor actor;
 597
 598   bool asserted = true;
 599   try
 600   {
 601     actor.SetFarClippingPlane( 2000.0f );
 602   }
 603   catch( Dali::DaliException& e )
 604   {
 605     DALI_TEST_PRINT_ASSERT( e );
 606     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 607     asserted = true;
 608   }
 609
 610   DALI_TEST_CHECK( asserted );
 611
 612   END_TEST;
 613 }
 614
 615 int UtcDaliCameraActorGetFarClippingPlaneP(void)
 616 {
 617   TestApplication application;
 618   tet_infoline( "Testing Dali::CameraActor Get Far clipping plane (P)" );
 619
 620   CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 621   float defaultValue = 800.0f + ( 0xFFFF >> 4 );
 622   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), defaultValue, TEST_LOCATION );
 623
 624   // Check getting the property.
 625   float value;
 626   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 627   DALI_TEST_EQUALS( defaultValue, value, FLOAT_EPSILON, TEST_LOCATION );
 628   END_TEST;
 629 }
 630
 631 int UtcDaliCameraActorGetFarClippingPlaneN(void)
 632 {
 633   TestApplication application;
 634   tet_infoline( "Testing Dali::CameraActor Get Far clipping plane (N)" );
 635
 636   CameraActor actor;
 637
 638   bool asserted = true;
 639   try
 640   {
 641     actor.GetFarClippingPlane();
 642   }
 643   catch( Dali::DaliException& e )
 644   {
 645     DALI_TEST_PRINT_ASSERT( e );
 646     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 647     asserted = true;
 648   }
 649
 650   DALI_TEST_CHECK( asserted );
 651
 652   END_TEST;
 653 }
 654
 655 int UtcDaliCameraActorSetTargetPositionP(void)
 656 {
 657   TestApplication application;
 658   tet_infoline( "Testing Dali::CameraActor Set Target Position (P)" );
 659
 660   CameraActor actor = CameraActor::New();
 661
 662   Vector3 target1( 10.0f, 20.0f, 30.0f );
 663   Vector3 target2( 15.0f, 25.0f, 35.0f );
 664
 665   // Set a value so we are not relying on a particular default for this test case.
 666   actor.SetTargetPosition( target1 );
 667   DALI_TEST_EQUALS( actor.GetTargetPosition(), target1, TEST_LOCATION );
 668
 669   actor.SetTargetPosition( target2 );
 670   DALI_TEST_EQUALS( actor.GetTargetPosition(), target2, TEST_LOCATION );
 671
 672   // Check setting the property.
 673   actor.SetProperty( CameraActor::Property::TARGET_POSITION, target1 );
 674   DALI_TEST_EQUALS( actor.GetTargetPosition(), target1, FLOAT_EPSILON, TEST_LOCATION );
 675   END_TEST;
 676 }
 677
 678 int UtcDaliCameraActorSetTargetPositionN(void)
 679 {
 680   TestApplication application;
 681   tet_infoline( "Testing Dali::CameraActor Set Target Position (N)" );
 682
 683   CameraActor actor;
 684
 685   bool asserted = true;
 686   try
 687   {
 688     actor.SetTargetPosition( Vector3( 10.0f, 20.0f, 30.0f ) );
 689   }
 690   catch( Dali::DaliException& e )
 691   {
 692     DALI_TEST_PRINT_ASSERT( e );
 693     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 694     asserted = true;
 695   }
 696   DALI_TEST_CHECK( asserted );
 697
 698   END_TEST;
 699 }
 700
 701 int UtcDaliCameraActorGetTargetPositionP(void)
 702 {
 703   TestApplication application;
 704   tet_infoline( "Testing Dali::CameraActor Get Target Position (P)" );
 705
 706   CameraActor actor = CameraActor::New();
 707   Vector3 defaultValue( Vector3::ZERO );
 708   DALI_TEST_EQUALS( actor.GetTargetPosition(), defaultValue, TEST_LOCATION );
 709
 710   // Check getting the property.
 711   Vector3 value;
 712   actor.GetProperty( CameraActor::Property::TARGET_POSITION ).Get( value );
 713   DALI_TEST_EQUALS( defaultValue, value, FLOAT_EPSILON, TEST_LOCATION );
 714   END_TEST;
 715 }
 716
 717 int UtcDaliCameraActorGetTargetPositionN(void)
 718 {
 719   TestApplication application;
 720   tet_infoline( "Testing Dali::CameraActor Get Target Position (N)" );
 721
 722   CameraActor actor;
 723
 724   bool asserted = true;
 725   try
 726   {
 727     actor.GetTargetPosition();
 728   }
 729   catch( Dali::DaliException& e )
 730   {
 731     DALI_TEST_PRINT_ASSERT( e );
 732     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 733     asserted = true;
 734   }
 735   DALI_TEST_CHECK( asserted );
 736
 737   END_TEST;
 738 }
 739
 740 int UtcDaliCameraActorSetInvertYAxisP(void)
 741 {
 742   TestApplication application;
 743   tet_infoline( "Testing Dali::CameraActor Set InvertYAxis (P)" );
 744
 745   CameraActor actor = CameraActor::New();
 746
 747   // Set a value so we are not relying on a particular default for this test case.
 748   actor.SetInvertYAxis( false );
 749   DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
 750
 751   actor.SetInvertYAxis( true );
 752   DALI_TEST_EQUALS( actor.GetInvertYAxis(), true, TEST_LOCATION );
 753
 754   actor.SetProperty( CameraActor::Property::INVERT_Y_AXIS, false );
 755   DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
 756   END_TEST;
 757 }
 758
 759 int UtcDaliCameraActorSetInvertYAxisN(void)
 760 {
 761   TestApplication application;
 762   tet_infoline( "Testing Dali::CameraActor Set InvertYAxis (N)" );
 763
 764   CameraActor actor;
 765
 766   bool asserted = true;
 767   try
 768   {
 769     actor.SetInvertYAxis( false );
 770   }
 771   catch( Dali::DaliException& e )
 772   {
 773     DALI_TEST_PRINT_ASSERT( e );
 774     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 775     asserted = true;
 776   }
 777   DALI_TEST_CHECK( asserted );
 778   END_TEST;
 779 }
 780
 781 int UtcDaliCameraActorGetInvertYAxisP(void)
 782 {
 783   TestApplication application;
 784   tet_infoline( "Testing Dali::CameraActor Get InvertYAxis (P)" );
 785
 786   // Check the default value.
 787   CameraActor actor = CameraActor::New();
 788   DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
 789
 790   // Check getting the property.
 791   bool bValue;
 792   actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS ).Get( bValue );
 793   DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
 794   END_TEST;
 795 }
 796
 797 int UtcDaliCameraActorGetInvertYAxisN(void)
 798 {
 799   TestApplication application;
 800   tet_infoline( "Testing Dali::CameraActor Get InvertYAxis (N)" );
 801
 802   CameraActor actor;
 803
 804   bool asserted = true;
 805   try
 806   {
 807     actor.GetInvertYAxis();
 808   }
 809   catch( Dali::DaliException& e )
 810   {
 811     DALI_TEST_PRINT_ASSERT( e );
 812     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 813     asserted = true;
 814   }
 815   DALI_TEST_CHECK( asserted );
 816   END_TEST;
 817 }
 818
 819 int UtcDaliCameraActorSetPerspectiveProjectionP(void)
 820 {
 821   TestApplication application;
 822   tet_infoline( "Testing Dali::CameraActor::SetPerspectiveProjection (P)" );
 823
 824   CameraActor actor = CameraActor::New();
 825   actor.SetPerspectiveProjection( Size( 100.f, 150.f ) );
 826
 827   DALI_TEST_CHECK( actor );
 828
 829   float value;
 830   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 831   DALI_TEST_EQUALS( 0.666666f, value, FLOAT_EPSILON, TEST_LOCATION );
 832   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 833   DALI_TEST_EQUALS( 0.489957f, value, FLOAT_EPSILON, TEST_LOCATION );
 834   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 835   DALI_TEST_EQUALS( 150.f, value, FLOAT_EPSILON, TEST_LOCATION );
 836   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 837   DALI_TEST_EQUALS( 4245.f, value, FLOAT_EPSILON, TEST_LOCATION );
 838
 839   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
 840
 841   // Ensure these values persist after adding to the stage and an update/render pass
 842   application.GetScene().Add( actor );
 843   application.SendNotification();
 844   application.Render();
 845
 846   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 847   DALI_TEST_EQUALS( 0.666666f, value, FLOAT_EPSILON, TEST_LOCATION );
 848   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 849   DALI_TEST_EQUALS( 0.489957f, value, FLOAT_EPSILON, TEST_LOCATION );
 850   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 851   DALI_TEST_EQUALS( 150.f, value, FLOAT_EPSILON, TEST_LOCATION );
 852   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 853   DALI_TEST_EQUALS( 4245.f, value, FLOAT_EPSILON, TEST_LOCATION );
 854
 855   // Call method with a ZERO size, this should reset the perspective projection using the size of the scene we've been added to
 856   actor.SetPerspectiveProjection( Vector2::ZERO );
 857
 858   DALI_TEST_EQUALS( 0.6f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 859   DALI_TEST_EQUALS( 0.489957f, actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 860   DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 861   DALI_TEST_EQUALS( 4895.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
 862   DALI_TEST_EQUALS( 1600.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
 863   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
 864
 865   END_TEST;
 866 }
 867
 868 int UtcDaliCameraActorSetPerspectiveProjectionN(void)
 869 {
 870   TestApplication application;
 871   tet_infoline( "Testing Dali::CameraActor::SetPerspectiveProjection (N)" );
 872
 873   CameraActor actor = CameraActor::New();
 874
 875   // Check that setting perspective projection without a size does not do anything.
 876   actor.SetPerspectiveProjection( Size::ZERO );
 877
 878   // So the default values should be the same as defined in CameraActor
 879   float nearClippingPlane = 800.0f;
 880   float farClippingPlane = nearClippingPlane + 2.0f * nearClippingPlane;
 881
 882   DALI_TEST_EQUALS( nearClippingPlane, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
 883   DALI_TEST_EQUALS( farClippingPlane, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
 884   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
 885
 886   END_TEST;
 887 }
 888
 889 int UtcDaliCameraActorSetOrthographicProjectionP1(void)
 890 {
 891   TestApplication application;
 892   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,1)" );
 893
 894   CameraActor actor = CameraActor::New( Size( 1080.0f, 1920.0f ) );
 895   DALI_TEST_CHECK( actor );
 896
 897   application.GetScene().Add( actor );
 898
 899   actor.SetOrthographicProjection( Size( 1080.0f, 1920.0f ) );
 900   application.SendNotification();
 901   application.Render( 0 );
 902   application.Render();
 903   application.SendNotification();
 904
 905   float defaultAspectRatio;
 906   float defaultFieldOfView;
 907   float defaultNearPlaneDistance;
 908   float defaultFarPlaneDistance;
 909   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
 910   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
 911   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
 912   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
 913   Vector3 defaultPos = actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
 914
 915   actor.SetOrthographicProjection( Size( 1080.0f, 1920.0f ) );
 916
 917   application.SendNotification();
 918   application.Render( 0 );
 919   application.Render();
 920   application.SendNotification();
 921
 922   float value;
 923   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 924   DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
 925   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 926   DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 927   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 928   DALI_TEST_EQUALS( defaultNearPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION );
 929   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 930   DALI_TEST_EQUALS( defaultFarPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION );
 931
 932   actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
 933   DALI_TEST_EQUALS( -540.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 934   actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
 935   DALI_TEST_EQUALS( 540.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 936   actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
 937   DALI_TEST_EQUALS( 960.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 938   actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
 939   DALI_TEST_EQUALS( -960.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 940
 941   Vector3 pos = actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
 942   DALI_TEST_EQUALS( defaultPos.z, pos.z, 0.001f, TEST_LOCATION );
 943
 944   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
 945   END_TEST;
 946 }
 947
 948 int UtcDaliCameraActorSetOrthographicProjectionN(void)
 949 {
 950   TestApplication application;
 951   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (N)" );
 952
 953   CameraActor actor;
 954   bool asserted = true;
 955   try
 956   {
 957     actor.GetProjectionMode();
 958   }
 959   catch( Dali::DaliException& e )
 960   {
 961     DALI_TEST_PRINT_ASSERT( e );
 962     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 963     asserted = true;
 964   }
 965   DALI_TEST_CHECK( asserted );
 966   END_TEST;
 967 }
 968
 969 int UtcDaliCameraActorSetOrthographicProjectionP2(void)
 970 {
 971   TestApplication application;
 972   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,2)" );
 973
 974   CameraActor actor = CameraActor::New();
 975   DALI_TEST_CHECK( actor );
 976
 977   float defaultAspectRatio;
 978   float defaultFieldOfView;
 979   float defaultNearPlaneDistance;
 980   float defaultFarPlaneDistance;
 981   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
 982   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
 983   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
 984   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
 985
 986   // Check setting with specific near and far plane distances.
 987   actor.SetOrthographicProjection( -100.0f, 200.0f, -300.0f, 500.0f, 400.0f, 4000.0f );
 988
 989   float value;
 990   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 991   DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
 992   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 993   DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 994   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 995   DALI_TEST_EQUALS( 400.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 996   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 997   DALI_TEST_EQUALS( 4000.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 998
 999   actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
1000   DALI_TEST_EQUALS( -100.0f, value, FLOAT_EPSILON, TEST_LOCATION );
1001   actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
1002   DALI_TEST_EQUALS( 200.0f, value, FLOAT_EPSILON, TEST_LOCATION );
1003   actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
1004   DALI_TEST_EQUALS( -300.0f, value, FLOAT_EPSILON, TEST_LOCATION );
1005   actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
1006   DALI_TEST_EQUALS( 500.0f, value, FLOAT_EPSILON, TEST_LOCATION );
1007
1008   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
1009
1010   END_TEST;
1011 }
1012
1013 int UtcDaliCameraActorSetOrthographicProjectionP3(void)
1014 {
1015   TestApplication application;
1016   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,3)" );
1017
1018   CameraActor actor = CameraActor::New();
1019   DALI_TEST_CHECK( actor );
1020
1021   float defaultAspectRatio;
1022   float defaultFieldOfView;
1023   float defaultNearPlaneDistance;
1024   float defaultFarPlaneDistance;
1025   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
1026   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
1027   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
1028   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
1029
1030   actor.SetProjectionMode( Dali::Camera::ORTHOGRAPHIC_PROJECTION );
1031
1032   actor.SetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE, -100.0f );
1033   actor.SetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE, 200.0f );
1034   actor.SetProperty( CameraActor::Property::TOP_PLANE_DISTANCE, -300.0f );
1035   actor.SetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE, 500.0f );
1036   actor.SetNearClippingPlane( 400.0f );
1037   actor.SetFarClippingPlane( 4000.0f );
1038
1039   float value;
1040   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
1041   DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
1042   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
1043   DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
1044   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
1045   DALI_TEST_EQUALS( 400.0f, value, FLOAT_EPSILON, TEST_LOCATION );
1046   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
1047   DALI_TEST_EQUALS( 4000.0f, value, FLOAT_EPSILON, TEST_LOCATION );
1048
1049   actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
1050   DALI_TEST_EQUALS( -100.0f, value, FLOAT_EPSILON, TEST_LOCATION );
1051   actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
1052   DALI_TEST_EQUALS( 200.0f, value, FLOAT_EPSILON, TEST_LOCATION );
1053   actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
1054   DALI_TEST_EQUALS( -300.0f, value, FLOAT_EPSILON, TEST_LOCATION );
1055   actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
1056   DALI_TEST_EQUALS( 500.0f, value, FLOAT_EPSILON, TEST_LOCATION );
1057
1058   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
1059   std::string stringValue;
1060   actor.GetProperty( CameraActor::Property::PROJECTION_MODE ).Get( stringValue );
1061   DALI_TEST_EQUALS( stringValue, "ORTHOGRAPHIC_PROJECTION", TEST_LOCATION );
1062   END_TEST;
1063 }
1064
1065 int UtcDaliCameraActorSetProjectionModeP(void)
1066 {
1067   TestApplication application;
1068   tet_infoline( "Testing Dali::CameraActor::SetProjectionModeP (P)" );
1069
1070   CameraActor actor = CameraActor::New();
1071
1072   // Check that changing the projection mode alone does not alter other presets.
1073   actor.SetNearClippingPlane( 200.0f );
1074   actor.SetFarClippingPlane( 400.0f );
1075
1076   actor.SetProjectionMode( Dali::Camera::PERSPECTIVE_PROJECTION );
1077
1078   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1079   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION );
1080   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION );
1081
1082   actor.SetProjectionMode( Dali::Camera::ORTHOGRAPHIC_PROJECTION );
1083
1084   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
1085   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION );
1086   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION );
1087
1088   // Check setting the property.
1089   Property::Value setValue = "PERSPECTIVE_PROJECTION";
1090   actor.SetProperty( CameraActor::Property::PROJECTION_MODE, setValue );
1091   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1092   END_TEST;
1093 }
1094
1095 int UtcDaliCameraActorSetProjectionModeN(void)
1096 {
1097   TestApplication application;
1098   tet_infoline( "Testing Dali::CameraActor::SetProjectionModeP (N)" );
1099
1100   CameraActor actor;
1101
1102   bool asserted = true;
1103   try
1104   {
1105     actor.SetProjectionMode( Dali::Camera::PERSPECTIVE_PROJECTION );
1106   }
1107   catch( Dali::DaliException& e )
1108   {
1109     DALI_TEST_PRINT_ASSERT( e );
1110     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
1111     asserted = true;
1112   }
1113   DALI_TEST_CHECK( asserted );
1114   END_TEST;
1115 }
1116
1117 int UtcDaliCameraActorGetProjectionModeP(void)
1118 {
1119   TestApplication application;
1120   tet_infoline( "Testing Dali::CameraActor::GetPerspectiveProjection (P)" );
1121
1122   CameraActor actor = CameraActor::New();
1123
1124   actor.SetOrthographicProjection( Size::ONE );
1125   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
1126
1127   actor.SetPerspectiveProjection( Size( 100.f, 150.f ) );
1128   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1129
1130   // Check getting the property.
1131   std::string stringValue;
1132   actor.GetProperty( CameraActor::Property::PROJECTION_MODE ).Get( stringValue );
1133   DALI_TEST_EQUALS( stringValue, "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 UtcDaliCameraActorSetCameraOffStage(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   actor.GetProperty( CameraActor::Property::PROJECTION_MODE).Get( sValue );
1193   DALI_TEST_EQUALS( "PERSPECTIVE_PROJECTION", sValue, TEST_LOCATION );
1194   bool bValue;
1195   actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS).Get( bValue );
1196   DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
1197   END_TEST;
1198 }
1199
1200 int UtcDaliCameraActorSetCameraOnStage(void)
1201 {
1202   TestApplication application;
1203   tet_infoline( "Testing Dali::CameraActor::SetCamera()" );
1204
1205   CameraActor actor = CameraActor::New();
1206   application.GetScene().Add( actor );
1207   application.Render( 0 );
1208   application.SendNotification();
1209
1210   actor.SetType( Camera::LOOK_AT_TARGET );
1211   actor.SetFieldOfView( TEST_FIELD_OF_VIEW );
1212   actor.SetAspectRatio( TEST_ASPECT_RATIO );
1213   actor.SetNearClippingPlane( TEST_NEAR_PLANE_DISTANCE );
1214   actor.SetFarClippingPlane( TEST_FAR_PLANE_DISTANCE );
1215   actor.SetInvertYAxis( false );
1216
1217   DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
1218
1219   // Will need 2 frames to ensure both buffers are set to same values:
1220   application.Render();
1221   application.SendNotification();
1222   application.Render();
1223   application.SendNotification();
1224
1225   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION );
1226   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION );
1227   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1228   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1229   DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
1230
1231   std::string sValue;
1232   actor.GetProperty( CameraActor::Property::TYPE ).Get( sValue );
1233   DALI_TEST_EQUALS( sValue, "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, "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::STRING,   true,    false,   true,   Dali::CameraActor::Property::TYPE                  },
1437     { "projectionMode",         Property::STRING,   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
1452   for( uint32_t index = 0; index < (sizeof(CAMERA_DEFAULT_PROPERTY)/sizeof(PropertyDetails)); ++index )
1453   {
1454     TEST_CAMERA_PROPERTY( actor,
1455                           CAMERA_DEFAULT_PROPERTY[ index ].name,
1456                           CAMERA_DEFAULT_PROPERTY[ index ].type,
1457                           CAMERA_DEFAULT_PROPERTY[ index ].writable,
1458                           CAMERA_DEFAULT_PROPERTY[ index ].animatable,
1459                           CAMERA_DEFAULT_PROPERTY[ index ].constraintInput,
1460                           CAMERA_DEFAULT_PROPERTY[ index ].enumIndex,
1461                           TEST_LOCATION );
1462   }
1463   END_TEST;
1464 }
1465
1466 int UtcDaliCameraActorModelView(void)
1467 {
1468   TestApplication application;
1469   tet_infoline( "Testing Dali::CameraActor Test view application" );
1470
1471   Actor actor = CreateRenderableActor();
1472   actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1473   actor.SetProperty( Actor::Property::POSITION, Vector3( 20.0f, 30.0f, 40.0f ));
1474   actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
1475   application.GetScene().Add( actor );
1476
1477   application.SendNotification();
1478   application.Render( 0 );
1479   application.Render();
1480   application.SendNotification();
1481
1482   Matrix resultMatrix( true );
1483   resultMatrix.SetTransformComponents( Vector3::ONE, Quaternion::IDENTITY, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ) );
1484
1485   RenderTask task = application.GetScene().GetRenderTaskList().GetTask( 0 );
1486   CameraActor cameraActor = task.GetCameraActor();
1487
1488   Matrix viewMatrix( false );
1489   cameraActor.GetProperty( CameraActor::Property::VIEW_MATRIX ).Get( viewMatrix );
1490   Matrix::Multiply( resultMatrix, resultMatrix, viewMatrix );
1491
1492   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( "uModelView", resultMatrix ) );
1493   END_TEST;
1494 }
1495
1496 int UtcDaliCameraActorReadProjectionMatrix(void)
1497 {
1498   TestApplication application;
1499   tet_infoline( "Testing Dali::CameraActor::ReadProjectionMatrix()" );
1500
1501   CameraActor camera = application.GetScene().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
1502   application.SendNotification();
1503   application.Render( 0 );
1504   application.Render();
1505   application.SendNotification();
1506   Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 4u, 4u);
1507   Actor actor = CreateRenderableActor( image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE );
1508   actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1509   application.GetScene().Add( actor );
1510
1511   Matrix projectionMatrix;
1512   Matrix viewMatrix;
1513
1514   camera.GetProperty( CameraActor::CameraActor::Property::PROJECTION_MATRIX ).Get( projectionMatrix );
1515   camera.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( viewMatrix );
1516
1517   actor.RegisterProperty( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
1518   actor.RegisterProperty( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
1519
1520   Property::Index projectionMatrixPropertyIndex = actor.GetPropertyIndex( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME );
1521   Property::Index viewMatrixPropertyIndex = actor.GetPropertyIndex( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME );
1522
1523   Constraint projectionMatrixConstraint = Constraint::New<Dali::Matrix>( actor, projectionMatrixPropertyIndex, EqualToConstraint() );
1524   projectionMatrixConstraint.AddSource( Source( camera, CameraActor::Property::PROJECTION_MATRIX ) );
1525   Constraint viewMatrixConstraint = Constraint::New<Dali::Matrix>( actor, viewMatrixPropertyIndex, EqualToConstraint() );
1526   viewMatrixConstraint.AddSource( Source( camera, CameraActor::Property::VIEW_MATRIX ) );
1527
1528   projectionMatrixConstraint.Apply();
1529   viewMatrixConstraint.Apply();
1530
1531   application.SendNotification();
1532   application.Render();
1533
1534   // Test effects of Constraint.
1535   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME.c_str(), projectionMatrix) );
1536
1537   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME.c_str(), viewMatrix ) );
1538   END_TEST;
1539 }
1540
1541 int UtcDaliCameraActorAnimatedProperties(void)
1542 {
1543   TestApplication application;
1544   tet_infoline( "Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()" );
1545
1546   CameraActor camera = application.GetScene().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
1547   Actor actor = Actor::New();
1548   actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1549   application.GetScene().Add( actor );
1550
1551   Constraint constraint = Constraint::New<Dali::Vector3>( actor, Actor::Property::POSITION, EqualToConstraint() );
1552   constraint.AddSource( Source( camera, Actor::Property::POSITION ) );
1553   constraint.Apply();
1554
1555   camera.SetProperty( Actor::Property::POSITION, Vector3( 100.0f, 200.0f, 300.0f ));
1556   application.SendNotification();
1557   application.Render();
1558
1559   DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 100.0f, 200.0f, 300.0f ), TEST_LOCATION);
1560   END_TEST;
1561 }
1562
1563 int UtcDaliCameraActorPropertyIndices(void)
1564 {
1565   TestApplication application;
1566   CameraActor camera = application.GetScene().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
1567
1568   Actor basicActor = Actor::New();
1569   Property::IndexContainer indices;
1570   camera.GetPropertyIndices( indices );
1571   DALI_TEST_CHECK( indices.Size() > basicActor.GetPropertyCount() );
1572   DALI_TEST_EQUALS( indices.Size(), camera.GetPropertyCount(), TEST_LOCATION );
1573   END_TEST;
1574 }
1575
1576 int UtcDaliCameraActorCheckLookAtAndFreeLookViews01(void)
1577 {
1578   TestApplication application;
1579   Integration::Scene stage = application.GetScene();
1580   Vector2 stageSize = stage.GetSize();
1581
1582   CameraActor freeLookCameraActor = CameraActor::New( stageSize );
1583   freeLookCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
1584   freeLookCameraActor.SetType( Camera::FREE_LOOK );
1585
1586   Vector3 targetPosition( 30.0f, 240.0f, -256.0f );
1587   Actor target = Actor::New();
1588   target.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
1589   target.SetProperty( Actor::Property::POSITION, targetPosition );
1590
1591   Constraint cameraOrientationConstraint = Constraint::New<Quaternion> ( freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt );
1592   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_POSITION ) );
1593   cameraOrientationConstraint.AddSource( Source( freeLookCameraActor,  Actor::Property::WORLD_POSITION ) );
1594   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_ORIENTATION ) );
1595   cameraOrientationConstraint.Apply();
1596
1597   CameraActor lookAtCameraActor = CameraActor::New( stageSize );
1598   lookAtCameraActor.SetType( Camera::LOOK_AT_TARGET );
1599   lookAtCameraActor.SetTargetPosition( targetPosition );
1600   lookAtCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
1601
1602   stage.Add( target );
1603   stage.Add( freeLookCameraActor );
1604   stage.Add( lookAtCameraActor );
1605
1606   // Create an arbitrary vector
1607   for( float x=-1.0f; x<=1.0f; x+=0.1f )
1608   {
1609     for( float y=-1.0f; y<1.0f; y+=0.1f )
1610     {
1611       for( float z=-1.0f; z<1.0f; z+=0.1f )
1612       {
1613         Vector3 position( x, y, z );
1614         position.Normalize();
1615         position *= 200.0f;
1616
1617         freeLookCameraActor.SetProperty( Actor::Property::POSITION, position );
1618         lookAtCameraActor.SetProperty( Actor::Property::POSITION, position );
1619
1620         application.SendNotification();
1621         application.Render();
1622         application.SendNotification();
1623         application.Render();
1624         Matrix freeLookViewMatrix;
1625         Matrix lookAtViewMatrix;
1626         freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
1627         lookAtCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( lookAtViewMatrix );
1628
1629         DALI_TEST_EQUALS( freeLookViewMatrix, lookAtViewMatrix, 0.01, TEST_LOCATION );
1630       }
1631     }
1632   }
1633   END_TEST;
1634 }
1635
1636 int UtcDaliCameraActorCheckLookAtAndFreeLookViews02(void)
1637 {
1638   TestApplication application;
1639   Integration::Scene stage = application.GetScene();
1640   Vector2 stageSize = stage.GetSize();
1641
1642   CameraActor freeLookCameraActor = CameraActor::New( stageSize );
1643   freeLookCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
1644   freeLookCameraActor.SetType( Camera::FREE_LOOK );
1645
1646   Vector3 targetPosition( 30.0f, 240.0f, -256.0f );
1647   Actor target = Actor::New();
1648   target.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
1649   target.SetProperty( Actor::Property::POSITION, targetPosition );
1650
1651   Constraint cameraOrientationConstraint = Constraint::New<Quaternion> ( freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt );
1652   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_POSITION ) );
1653   cameraOrientationConstraint.AddSource( Source( freeLookCameraActor,  Actor::Property::WORLD_POSITION ) );
1654   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_ORIENTATION ) );
1655   cameraOrientationConstraint.Apply();
1656
1657   CameraActor lookAtCameraActor = CameraActor::New( stageSize );
1658   lookAtCameraActor.SetType( Camera::LOOK_AT_TARGET );
1659   lookAtCameraActor.SetTargetPosition( targetPosition );
1660   lookAtCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
1661
1662   stage.Add( target );
1663   stage.Add( freeLookCameraActor );
1664   stage.Add( lookAtCameraActor );
1665   stage.GetRenderTaskList().GetTask(0).SetCameraActor( freeLookCameraActor );
1666
1667   // Create an arbitrary vector
1668   for( float x=-1.0f; x<=1.0f; x+=0.1f )
1669   {
1670     for( float y=-1.0f; y<1.0f; y+=0.1f )
1671     {
1672       for( float z=-1.0f; z<1.0f; z+=0.1f )
1673       {
1674         Vector3 position( x, y, z );
1675         position.Normalize();
1676         position *= 200.0f;
1677
1678         freeLookCameraActor.SetProperty( Actor::Property::POSITION, position );
1679         lookAtCameraActor.SetProperty( Actor::Property::POSITION, position );
1680
1681         application.SendNotification();
1682         application.Render();
1683         application.SendNotification();
1684         application.Render();
1685         Matrix freeLookViewMatrix;
1686         freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
1687
1688         Matrix freeLookWorld = freeLookCameraActor.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
1689
1690         Matrix freeLookTest( false );
1691         Matrix::Multiply( freeLookTest, freeLookViewMatrix, freeLookWorld );
1692         DALI_TEST_EQUALS( freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION );
1693       }
1694     }
1695   }
1696
1697   END_TEST;
1698 }
1699
1700 int UtcDaliCameraActorCheckLookAtAndFreeLookViews03(void)
1701 {
1702   TestApplication application;
1703   Integration::Scene stage = application.GetScene();
1704   Vector2 stageSize = stage.GetSize();
1705
1706   Vector3 targetPosition( Vector3::ZERO );
1707   Vector3 cameraOffset( 0.0f, 0.0f, 100.0f );
1708
1709   CameraActor freeLookCameraActor = CameraActor::New( stageSize );
1710   freeLookCameraActor.SetType( Camera::FREE_LOOK );
1711   freeLookCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
1712
1713   Quaternion cameraOrientation( Radian( Degree( 180.0f ) ), Vector3::YAXIS );
1714   freeLookCameraActor.SetProperty( Actor::Property::POSITION, cameraOffset );
1715   freeLookCameraActor.SetProperty( Actor::Property::ORIENTATION, cameraOrientation );
1716
1717   Actor cameraAnchor = Actor::New();
1718   cameraAnchor.Add( freeLookCameraActor );
1719   stage.Add( cameraAnchor );
1720   stage.GetRenderTaskList().GetTask(0).SetCameraActor( freeLookCameraActor );
1721
1722   for( float angle = 1.0f; angle <= 180.0f; angle += 1.0f )
1723   {
1724     Quaternion rotation( Radian( Degree( angle ) ), Vector3::YAXIS );
1725
1726     freeLookCameraActor.SetProperty( Actor::Property::POSITION, rotation.Rotate( cameraOffset ) );
1727     cameraAnchor.SetProperty( Actor::Property::ORIENTATION, rotation );
1728
1729     application.SendNotification();
1730     application.Render();
1731     application.SendNotification();
1732     application.Render();
1733
1734     Matrix freeLookViewMatrix;
1735     freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
1736
1737     Matrix freeLookWorld = freeLookCameraActor.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
1738
1739     Matrix freeLookTest( false );
1740     Matrix::Multiply( freeLookTest,  freeLookViewMatrix,  freeLookWorld );
1741     DALI_TEST_EQUALS( freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION );
1742   }
1743   END_TEST;
1744 }
1745
1746 int UtcDaliCameraActorReflectionByPlane(void)
1747 {
1748   TestApplication application;
1749
1750   Integration::Scene stage = application.GetScene();
1751
1752   Vector3 targetPosition( Vector3::ZERO );
1753   Vector3 cameraOffset( 0.0f, 100.0f, 100.0f );
1754
1755   CameraActor freeLookCameraActor = stage.GetRenderTaskList().GetTask(0).GetCameraActor();
1756   freeLookCameraActor.SetType(Camera::LOOK_AT_TARGET);
1757   freeLookCameraActor.SetTargetPosition( targetPosition );
1758   freeLookCameraActor.SetProperty( Actor::Property::POSITION, cameraOffset );
1759
1760   stage.GetRootLayer().SetProperty( Actor::Property::POSITION, Vector2( 1, 0 ));
1761
1762   application.SendNotification();
1763   application.Render();
1764   application.SendNotification();
1765   application.Render();
1766
1767   Matrix matrixBefore, matrixAfter;
1768   freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( matrixBefore );
1769   freeLookCameraActor.SetProperty( Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4( 0.0f, 1.0f, 0.0f, 0.0f));
1770   stage.GetRootLayer().SetProperty( Actor::Property::POSITION, Vector2( 0, 0 ));
1771   application.SendNotification();
1772   application.Render();
1773   application.SendNotification();
1774   application.Render();
1775
1776   freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( matrixAfter );
1777
1778   Vector3 position, scale;
1779   Quaternion rotation;
1780   matrixAfter.GetTransformComponents( position, rotation, scale );
1781
1782   Quaternion reflected( 0, 0, 1, 0 );
1783
1784   DALI_TEST_EQUALS( reflected, rotation, 0.01f, TEST_LOCATION );
1785
1786   // Test Free Look camera
1787   freeLookCameraActor.SetType(Camera::FREE_LOOK);
1788
1789   // Make sure the recalculation will take place
1790   freeLookCameraActor.SetProperty( Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4( 0.0f, 1.0f, 0.0f, 0.0f));
1791
1792   application.SendNotification();
1793   application.Render();
1794   application.SendNotification();
1795   application.Render();
1796
1797   // Nothing should change despite of different camera type
1798   matrixAfter.GetTransformComponents( position, rotation, scale );
1799   DALI_TEST_EQUALS( reflected, rotation, 0.01f, TEST_LOCATION );
1800
1801   END_TEST;
1802 }