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

   1 /*
   2  * Copyright (c) 2017 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
  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 // Note: No negative test for UtcDaliCameraActorNew.
 181
 182 int UtcDaliCameraActorDownCastP(void)
 183 {
 184   TestApplication application;
 185   tet_infoline( "Testing Dali::CameraActor::DownCast (P)" );
 186
 187   CameraActor camera = CameraActor::New();
 188   Actor anActor = Actor::New();
 189   anActor.Add( camera );
 190
 191   Actor child = anActor.GetChildAt( 0 );
 192   CameraActor cameraActor = CameraActor::DownCast( child );
 193   DALI_TEST_CHECK( cameraActor );
 194
 195   cameraActor.Reset();
 196   DALI_TEST_CHECK( !cameraActor );
 197
 198   cameraActor = DownCast< CameraActor >( child );
 199   DALI_TEST_CHECK( cameraActor );
 200   END_TEST;
 201 }
 202
 203 int UtcDaliCameraActorDownCastN(void)
 204 {
 205   TestApplication application;
 206   tet_infoline( "Testing Dali::CameraActor::DownCast (N)" );
 207
 208   Actor actor1 = Actor::New();
 209   Actor anActor = Actor::New();
 210   anActor.Add( actor1 );
 211
 212   Actor child = anActor.GetChildAt( 0 );
 213   CameraActor cameraActor = CameraActor::DownCast( child );
 214   DALI_TEST_CHECK( !cameraActor );
 215
 216   Actor unInitialzedActor;
 217   cameraActor = CameraActor::DownCast( unInitialzedActor );
 218   DALI_TEST_CHECK( !cameraActor );
 219
 220   cameraActor = DownCast< CameraActor >( unInitialzedActor );
 221   DALI_TEST_CHECK( !cameraActor );
 222   END_TEST;
 223 }
 224
 225 // Note: SetType and GetType are tested within the same test cases.
 226
 227 int UtcDaliCameraActorSetGetTypeP(void)
 228 {
 229   TestApplication application;
 230   tet_infoline( "Testing Dali::CameraActor GetType (P)" );
 231
 232   CameraActor actor = CameraActor::New();
 233   DALI_TEST_EQUALS( actor.GetType(), Dali::Camera::FREE_LOOK, TEST_LOCATION );
 234
 235   actor.SetType( Dali::Camera::LOOK_AT_TARGET );
 236   DALI_TEST_EQUALS( actor.GetType(), Dali::Camera::LOOK_AT_TARGET, TEST_LOCATION );
 237
 238   DALI_TEST_EQUALS( "LOOK_AT_TARGET", actor.GetProperty< std::string >( CameraActor::Property::TYPE ), TEST_LOCATION );
 239   DALI_TEST_EQUALS( "LOOK_AT_TARGET", actor.GetCurrentProperty< std::string >( CameraActor::Property::TYPE ), TEST_LOCATION );
 240   END_TEST;
 241 }
 242
 243 int UtcDaliCameraActorSetGetTypeN(void)
 244 {
 245   TestApplication application;
 246   tet_infoline( "Testing Dali::CameraActor GetType (N)" );
 247
 248   CameraActor actor;
 249
 250   Dali::Camera::Type cameraType = Dali::Camera::FREE_LOOK;
 251   try
 252   {
 253     cameraType = actor.GetType();
 254   }
 255   catch ( Dali::DaliException& e )
 256   {
 257     DALI_TEST_PRINT_ASSERT( e );
 258     DALI_TEST_ASSERT( e, "camera", TEST_LOCATION );
 259   }
 260
 261   const CameraActor aConstActor;
 262
 263   try
 264   {
 265     cameraType = aConstActor.GetType();
 266   }
 267   catch ( Dali::DaliException& e )
 268   {
 269     DALI_TEST_PRINT_ASSERT( e );
 270     DALI_TEST_ASSERT( e, "camera", TEST_LOCATION );
 271   }
 272
 273   DALI_TEST_EQUALS( cameraType, Dali::Camera::FREE_LOOK, TEST_LOCATION );
 274   END_TEST;
 275 }
 276
 277 int UtcDaliCameraActorSetFieldOfViewP(void)
 278 {
 279   TestApplication application;
 280   tet_infoline( "Testing Dali::CameraActor Set Field of view (P)" );
 281
 282   CameraActor defaultCamera = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 283   const float defaultFieldOfView = defaultCamera.GetFieldOfView();
 284
 285   CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 286   DALI_TEST_EQUALS( actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION );
 287
 288   float fieldOfView = Math::PI / 3.0f;
 289   actor.SetFieldOfView( fieldOfView );
 290   DALI_TEST_EQUALS( actor.GetFieldOfView(), fieldOfView, TEST_LOCATION );
 291
 292   float value;
 293   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 294   DALI_TEST_EQUALS( fieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 295   END_TEST;
 296 }
 297
 298 int UtcDaliCameraActorSetFieldOfViewN(void)
 299 {
 300   TestApplication application;
 301   tet_infoline( "Testing Dali::CameraActor Set Field of view (N)" );
 302
 303   CameraActor defaultCamera = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 304   const float defaultFieldOfView = defaultCamera.GetFieldOfView();
 305
 306   CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 307   DALI_TEST_EQUALS( actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION );
 308
 309   float fieldOfView = Math::PI / 3.0f;
 310   actor.SetFieldOfView( fieldOfView );
 311   DALI_TEST_EQUALS( actor.GetFieldOfView(), fieldOfView, TEST_LOCATION );
 312
 313   float value;
 314   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 315   DALI_TEST_EQUALS( fieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 316   END_TEST;
 317 }
 318
 319 int UtcDaliCameraActorGetFieldOfViewP(void)
 320 {
 321   TestApplication application;
 322   tet_infoline( "Testing Dali::CameraActor Get Field of view (P)" );
 323   const Vector2 size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
 324
 325   CameraActor defaultCamera = CameraActor::New( size );
 326
 327   const float cameraZ = 2.0f * std::max( size.width, size.height );
 328   const float expectedFieldOfView = 2.0f * std::atan( size.height * 0.5f / cameraZ );
 329
 330   CameraActor actor = CameraActor::New( size );
 331   DALI_TEST_EQUALS( actor.GetFieldOfView(), expectedFieldOfView, TEST_LOCATION );
 332
 333   float value;
 334   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 335   DALI_TEST_EQUALS( expectedFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
 336   END_TEST;
 337 }
 338
 339 int UtcDaliCameraActorGetFieldOfViewN(void)
 340 {
 341   TestApplication application;
 342   tet_infoline( "Testing Dali::CameraActor Get Field of view (N)" );
 343
 344   CameraActor defaultCamera = CameraActor::New();
 345
 346   bool asserted = true;
 347   try
 348   {
 349     defaultCamera.GetFieldOfView();
 350   }
 351   catch( Dali::DaliException& e )
 352   {
 353     DALI_TEST_PRINT_ASSERT( e );
 354     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 355     asserted = true;
 356   }
 357   DALI_TEST_CHECK( asserted );
 358
 359   END_TEST;
 360 }
 361
 362 int UtcDaliCameraActorSetAspectRatioP(void)
 363 {
 364   TestApplication application;
 365   tet_infoline( "Testing Dali::CameraActor Set Aspect Ratio (P)" );
 366
 367   CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 368   DALI_TEST_EQUALS( actor.GetAspectRatio(), static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ) / static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT ), TEST_LOCATION );
 369
 370   // Set an initial value to confirm a further set changes it.
 371   float aspect = 4.0f / 3.0f;
 372   actor.SetAspectRatio( aspect );
 373   DALI_TEST_EQUALS( actor.GetAspectRatio(), aspect, TEST_LOCATION );
 374
 375   aspect = 16.0f / 9.0f;
 376   actor.SetAspectRatio( aspect );
 377   DALI_TEST_EQUALS( actor.GetAspectRatio(), aspect, TEST_LOCATION );
 378
 379   END_TEST;
 380 }
 381
 382 int UtcDaliCameraActorSetAspectRatioN(void)
 383 {
 384   TestApplication application;
 385   tet_infoline( "Testing Dali::CameraActor Set Aspect Ratio (N)" );
 386
 387   CameraActor actor;
 388
 389   bool asserted = true;
 390   try
 391   {
 392     actor.SetAspectRatio( 16.0f / 9.0f );
 393   }
 394   catch( Dali::DaliException& e )
 395   {
 396     DALI_TEST_PRINT_ASSERT( e );
 397     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 398     asserted = true;
 399   }
 400   DALI_TEST_CHECK( asserted );
 401
 402   END_TEST;
 403 }
 404
 405 int UtcDaliCameraActorGetAspectRatioP(void)
 406 {
 407   TestApplication application;
 408   tet_infoline("Testing Dali::CameraActor Get Aspect Ratio");
 409
 410   CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 411   float defaultAspect = static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ) / static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT );
 412
 413   DALI_TEST_EQUALS( actor.GetAspectRatio(), defaultAspect, TEST_LOCATION );
 414
 415   float value = 0.0f;
 416   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 417   DALI_TEST_EQUALS( defaultAspect, value, FLOAT_EPSILON, TEST_LOCATION );
 418
 419   END_TEST;
 420 }
 421
 422 int UtcDaliCameraActorGetAspectRatioN(void)
 423 {
 424   TestApplication application;
 425   tet_infoline( "Testing Dali::CameraActor Get Aspect Ratio (N)" );
 426
 427   CameraActor actor;
 428
 429   bool asserted = true;
 430   try
 431   {
 432     actor.GetAspectRatio();
 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
 441   DALI_TEST_CHECK( asserted );
 442
 443   END_TEST;
 444 }
 445
 446 int UtcDaliCameraActorSetNearClippingPlaneP(void)
 447 {
 448   TestApplication application;
 449   tet_infoline( "Testing Dali::CameraActor Set Near clipping plane (P)" );
 450
 451   CameraActor actor = CameraActor::New();
 452
 453   // Set a value so we are not relying on a particular default for this test case.
 454   actor.SetNearClippingPlane( 200.0f );
 455   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, TEST_LOCATION );
 456
 457   actor.SetNearClippingPlane( 400.0f );
 458   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 400.0f, TEST_LOCATION );
 459
 460   // Check setting the property.
 461   actor.SetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE, Property::Value( 300.0f ) );
 462   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 300.0f, FLOAT_EPSILON, TEST_LOCATION );
 463   END_TEST;
 464 }
 465
 466 int UtcDaliCameraActorSetNearClippingPlaneN(void)
 467 {
 468   TestApplication application;
 469   tet_infoline( "Testing Dali::CameraActor Set Near clipping plane (N)" );
 470
 471   CameraActor actor;
 472
 473   bool asserted = true;
 474   try
 475   {
 476     actor.SetNearClippingPlane( 200.0f );
 477   }
 478   catch( Dali::DaliException& e )
 479   {
 480     DALI_TEST_PRINT_ASSERT( e );
 481     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 482     asserted = true;
 483   }
 484
 485   DALI_TEST_CHECK( asserted );
 486
 487   END_TEST;
 488 }
 489
 490 int UtcDaliCameraActorGetNearClippingPlaneP(void)
 491 {
 492   TestApplication application;
 493   tet_infoline( "Testing Dali::CameraActor Get Near clipping plane (P)" );
 494
 495   // Check the default value.
 496   CameraActor actor = CameraActor::New();
 497   float defaultValue = 800.0f;
 498   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), defaultValue, TEST_LOCATION );
 499
 500   // Check getting the property.
 501   float value;
 502   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 503   DALI_TEST_EQUALS( defaultValue, value, FLOAT_EPSILON, TEST_LOCATION );
 504   END_TEST;
 505 }
 506
 507 int UtcDaliCameraActorGetNearClippingPlaneN(void)
 508 {
 509   TestApplication application;
 510   tet_infoline( "Testing Dali::CameraActor Get Near clipping plane (N)" );
 511
 512   CameraActor actor;
 513   bool asserted = true;
 514   try
 515   {
 516     actor.GetNearClippingPlane();
 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 UtcDaliCameraActorSetFarClippingPlaneP(void)
 531 {
 532   TestApplication application;
 533   tet_infoline( "Testing Dali::CameraActor Set Far clipping plane (P)" );
 534
 535   CameraActor actor = CameraActor::New();
 536
 537   // Set a value so we are not relying on a particular default for this test case.
 538   actor.SetFarClippingPlane( 2000.0f );
 539   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 2000.0f, TEST_LOCATION );
 540
 541   actor.SetFarClippingPlane( 4000.0f );
 542   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 4000.0f, TEST_LOCATION );
 543
 544   // Check setting the property.
 545   actor.SetProperty( CameraActor::Property::FAR_PLANE_DISTANCE, 2000.0f );
 546   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 2000.0f, FLOAT_EPSILON, TEST_LOCATION );
 547   END_TEST;
 548 }
 549
 550 int UtcDaliCameraActorSetFarClippingPlaneN(void)
 551 {
 552   TestApplication application;
 553   tet_infoline( "Testing Dali::CameraActor Set Far clipping plane (N)" );
 554
 555   CameraActor actor;
 556
 557   bool asserted = true;
 558   try
 559   {
 560     actor.SetFarClippingPlane( 2000.0f );
 561   }
 562   catch( Dali::DaliException& e )
 563   {
 564     DALI_TEST_PRINT_ASSERT( e );
 565     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 566     asserted = true;
 567   }
 568
 569   DALI_TEST_CHECK( asserted );
 570
 571   END_TEST;
 572 }
 573
 574 int UtcDaliCameraActorGetFarClippingPlaneP(void)
 575 {
 576   TestApplication application;
 577   tet_infoline( "Testing Dali::CameraActor Get Far clipping plane (P)" );
 578
 579   CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
 580   float defaultValue = 800.0f + ( 0xFFFF >> 4 );
 581   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), defaultValue, TEST_LOCATION );
 582
 583   // Check getting the property.
 584   float value;
 585   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 586   DALI_TEST_EQUALS( defaultValue, value, FLOAT_EPSILON, TEST_LOCATION );
 587   END_TEST;
 588 }
 589
 590 int UtcDaliCameraActorGetFarClippingPlaneN(void)
 591 {
 592   TestApplication application;
 593   tet_infoline( "Testing Dali::CameraActor Get Far clipping plane (N)" );
 594
 595   CameraActor actor;
 596
 597   bool asserted = true;
 598   try
 599   {
 600     actor.GetFarClippingPlane();
 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 UtcDaliCameraActorSetTargetPositionP(void)
 615 {
 616   TestApplication application;
 617   tet_infoline( "Testing Dali::CameraActor Set Target Position (P)" );
 618
 619   CameraActor actor = CameraActor::New();
 620
 621   Vector3 target1( 10.0f, 20.0f, 30.0f );
 622   Vector3 target2( 15.0f, 25.0f, 35.0f );
 623
 624   // Set a value so we are not relying on a particular default for this test case.
 625   actor.SetTargetPosition( target1 );
 626   DALI_TEST_EQUALS( actor.GetTargetPosition(), target1, TEST_LOCATION );
 627
 628   actor.SetTargetPosition( target2 );
 629   DALI_TEST_EQUALS( actor.GetTargetPosition(), target2, TEST_LOCATION );
 630
 631   // Check setting the property.
 632   actor.SetProperty( CameraActor::Property::TARGET_POSITION, target1 );
 633   DALI_TEST_EQUALS( actor.GetTargetPosition(), target1, FLOAT_EPSILON, TEST_LOCATION );
 634   END_TEST;
 635 }
 636
 637 int UtcDaliCameraActorSetTargetPositionN(void)
 638 {
 639   TestApplication application;
 640   tet_infoline( "Testing Dali::CameraActor Set Target Position (N)" );
 641
 642   CameraActor actor;
 643
 644   bool asserted = true;
 645   try
 646   {
 647     actor.SetTargetPosition( Vector3( 10.0f, 20.0f, 30.0f ) );
 648   }
 649   catch( Dali::DaliException& e )
 650   {
 651     DALI_TEST_PRINT_ASSERT( e );
 652     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 653     asserted = true;
 654   }
 655   DALI_TEST_CHECK( asserted );
 656
 657   END_TEST;
 658 }
 659
 660 int UtcDaliCameraActorGetTargetPositionP(void)
 661 {
 662   TestApplication application;
 663   tet_infoline( "Testing Dali::CameraActor Get Target Position (P)" );
 664
 665   CameraActor actor = CameraActor::New();
 666   Vector3 defaultValue( Vector3::ZERO );
 667   DALI_TEST_EQUALS( actor.GetTargetPosition(), defaultValue, TEST_LOCATION );
 668
 669   // Check getting the property.
 670   Vector3 value;
 671   actor.GetProperty( CameraActor::Property::TARGET_POSITION ).Get( value );
 672   DALI_TEST_EQUALS( defaultValue, value, FLOAT_EPSILON, TEST_LOCATION );
 673   END_TEST;
 674 }
 675
 676 int UtcDaliCameraActorGetTargetPositionN(void)
 677 {
 678   TestApplication application;
 679   tet_infoline( "Testing Dali::CameraActor Get Target Position (N)" );
 680
 681   CameraActor actor;
 682
 683   bool asserted = true;
 684   try
 685   {
 686     actor.GetTargetPosition();
 687   }
 688   catch( Dali::DaliException& e )
 689   {
 690     DALI_TEST_PRINT_ASSERT( e );
 691     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 692     asserted = true;
 693   }
 694   DALI_TEST_CHECK( asserted );
 695
 696   END_TEST;
 697 }
 698
 699 int UtcDaliCameraActorSetInvertYAxisP(void)
 700 {
 701   TestApplication application;
 702   tet_infoline( "Testing Dali::CameraActor Set InvertYAxis (P)" );
 703
 704   CameraActor actor = CameraActor::New();
 705
 706   // Set a value so we are not relying on a particular default for this test case.
 707   actor.SetInvertYAxis( false );
 708   DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
 709
 710   actor.SetInvertYAxis( true );
 711   DALI_TEST_EQUALS( actor.GetInvertYAxis(), true, TEST_LOCATION );
 712
 713   actor.SetProperty( CameraActor::Property::INVERT_Y_AXIS, false );
 714   DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
 715   END_TEST;
 716 }
 717
 718 int UtcDaliCameraActorSetInvertYAxisN(void)
 719 {
 720   TestApplication application;
 721   tet_infoline( "Testing Dali::CameraActor Set InvertYAxis (N)" );
 722
 723   CameraActor actor;
 724
 725   bool asserted = true;
 726   try
 727   {
 728     actor.SetInvertYAxis( false );
 729   }
 730   catch( Dali::DaliException& e )
 731   {
 732     DALI_TEST_PRINT_ASSERT( e );
 733     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 734     asserted = true;
 735   }
 736   DALI_TEST_CHECK( asserted );
 737   END_TEST;
 738 }
 739
 740 int UtcDaliCameraActorGetInvertYAxisP(void)
 741 {
 742   TestApplication application;
 743   tet_infoline( "Testing Dali::CameraActor Get InvertYAxis (P)" );
 744
 745   // Check the default value.
 746   CameraActor actor = CameraActor::New();
 747   DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
 748
 749   // Check getting the property.
 750   bool bValue;
 751   actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS ).Get( bValue );
 752   DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
 753   END_TEST;
 754 }
 755
 756 int UtcDaliCameraActorGetInvertYAxisN(void)
 757 {
 758   TestApplication application;
 759   tet_infoline( "Testing Dali::CameraActor Get InvertYAxis (N)" );
 760
 761   CameraActor actor;
 762
 763   bool asserted = true;
 764   try
 765   {
 766     actor.GetInvertYAxis();
 767   }
 768   catch( Dali::DaliException& e )
 769   {
 770     DALI_TEST_PRINT_ASSERT( e );
 771     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 772     asserted = true;
 773   }
 774   DALI_TEST_CHECK( asserted );
 775   END_TEST;
 776 }
 777
 778 int UtcDaliCameraActorSetPerspectiveProjectionP(void)
 779 {
 780   TestApplication application;
 781   tet_infoline( "Testing Dali::CameraActor::SetPerspectiveProjection (P)" );
 782
 783   CameraActor actor = CameraActor::New();
 784   actor.SetPerspectiveProjection( Size( 100.f, 150.f ) );
 785
 786   DALI_TEST_CHECK( actor );
 787
 788   float value;
 789   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 790   DALI_TEST_EQUALS( 0.666666f, value, FLOAT_EPSILON, TEST_LOCATION );
 791   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 792   DALI_TEST_EQUALS( 0.489957f, value, FLOAT_EPSILON, TEST_LOCATION );
 793   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 794   DALI_TEST_EQUALS( 150.f, value, FLOAT_EPSILON, TEST_LOCATION );
 795   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 796   DALI_TEST_EQUALS( 4245.f, value, FLOAT_EPSILON, TEST_LOCATION );
 797
 798   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
 799
 800   END_TEST;
 801 }
 802
 803 int UtcDaliCameraActorSetPerspectiveProjectionN(void)
 804 {
 805   TestApplication application;
 806   tet_infoline( "Testing Dali::CameraActor::SetPerspectiveProjection (N)" );
 807
 808   CameraActor actor = CameraActor::New();
 809
 810   // Check that setting perspective projection without a size does not do anything.
 811   actor.SetPerspectiveProjection( Size::ZERO );
 812
 813   // So the default values should be the same as defined in CameraActor
 814   float nearClippingPlane = 800.0f;
 815   float farClippingPlane = nearClippingPlane + 2.0f * nearClippingPlane;
 816
 817   DALI_TEST_EQUALS( nearClippingPlane, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
 818   DALI_TEST_EQUALS( farClippingPlane, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
 819   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
 820
 821   END_TEST;
 822 }
 823
 824 int UtcDaliCameraActorSetOrthographicProjectionP1(void)
 825 {
 826   TestApplication application;
 827   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,1)" );
 828
 829   CameraActor actor = CameraActor::New( Size( 1080.0f, 1920.0f ) );
 830   DALI_TEST_CHECK( actor );
 831
 832   Stage::GetCurrent().Add( actor );
 833
 834   actor.SetOrthographicProjection( Size( 1080.0f, 1920.0f ) );
 835   application.SendNotification();
 836   application.Render( 0 );
 837   application.Render();
 838   application.SendNotification();
 839
 840   float defaultAspectRatio;
 841   float defaultFieldOfView;
 842   float defaultNearPlaneDistance;
 843   float defaultFarPlaneDistance;
 844   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
 845   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
 846   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
 847   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
 848   Vector3 defaultPos = actor.GetCurrentPosition();
 849
 850   actor.SetOrthographicProjection( Size( 1080.0f, 1920.0f ) );
 851
 852   application.SendNotification();
 853   application.Render( 0 );
 854   application.Render();
 855   application.SendNotification();
 856
 857   float value;
 858   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 859   DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
 860   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 861   DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 862   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 863   DALI_TEST_EQUALS( defaultNearPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION );
 864   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 865   DALI_TEST_EQUALS( defaultFarPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION );
 866
 867   actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
 868   DALI_TEST_EQUALS( -540.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 869   actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
 870   DALI_TEST_EQUALS( 540.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 871   actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
 872   DALI_TEST_EQUALS( 960.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 873   actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
 874   DALI_TEST_EQUALS( -960.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 875
 876   Vector3 pos = actor.GetCurrentPosition();
 877   DALI_TEST_EQUALS( defaultPos.z, pos.z, 0.001f, TEST_LOCATION );
 878
 879   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
 880   END_TEST;
 881 }
 882
 883 int UtcDaliCameraActorSetOrthographicProjectionN(void)
 884 {
 885   TestApplication application;
 886   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (N)" );
 887
 888   CameraActor actor;
 889   bool asserted = true;
 890   try
 891   {
 892     actor.GetProjectionMode();
 893   }
 894   catch( Dali::DaliException& e )
 895   {
 896     DALI_TEST_PRINT_ASSERT( e );
 897     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 898     asserted = true;
 899   }
 900   DALI_TEST_CHECK( asserted );
 901   END_TEST;
 902 }
 903
 904 int UtcDaliCameraActorSetOrthographicProjectionP2(void)
 905 {
 906   TestApplication application;
 907   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,2)" );
 908
 909   CameraActor actor = CameraActor::New();
 910   DALI_TEST_CHECK( actor );
 911
 912   float defaultAspectRatio;
 913   float defaultFieldOfView;
 914   float defaultNearPlaneDistance;
 915   float defaultFarPlaneDistance;
 916   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
 917   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
 918   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
 919   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
 920
 921   // Check setting with specific near and far plane distances.
 922   actor.SetOrthographicProjection( -100.0f, 200.0f, -300.0f, 500.0f, 400.0f, 4000.0f );
 923
 924   float value;
 925   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 926   DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
 927   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 928   DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 929   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 930   DALI_TEST_EQUALS( 400.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 931   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 932   DALI_TEST_EQUALS( 4000.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 933
 934   actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
 935   DALI_TEST_EQUALS( -100.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 936   actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
 937   DALI_TEST_EQUALS( 200.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 938   actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
 939   DALI_TEST_EQUALS( -300.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 940   actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
 941   DALI_TEST_EQUALS( 500.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 942
 943   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
 944
 945   END_TEST;
 946 }
 947
 948 int UtcDaliCameraActorSetOrthographicProjectionP3(void)
 949 {
 950   TestApplication application;
 951   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,3)" );
 952
 953   CameraActor actor = CameraActor::New();
 954   DALI_TEST_CHECK( actor );
 955
 956   float defaultAspectRatio;
 957   float defaultFieldOfView;
 958   float defaultNearPlaneDistance;
 959   float defaultFarPlaneDistance;
 960   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
 961   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
 962   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
 963   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
 964
 965   actor.SetProjectionMode( Dali::Camera::ORTHOGRAPHIC_PROJECTION );
 966
 967   actor.SetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE, -100.0f );
 968   actor.SetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE, 200.0f );
 969   actor.SetProperty( CameraActor::Property::TOP_PLANE_DISTANCE, -300.0f );
 970   actor.SetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE, 500.0f );
 971   actor.SetNearClippingPlane( 400.0f );
 972   actor.SetFarClippingPlane( 4000.0f );
 973
 974   float value;
 975   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 976   DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
 977   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 978   DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 979   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 980   DALI_TEST_EQUALS( 400.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 981   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 982   DALI_TEST_EQUALS( 4000.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 983
 984   actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
 985   DALI_TEST_EQUALS( -100.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 986   actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
 987   DALI_TEST_EQUALS( 200.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 988   actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
 989   DALI_TEST_EQUALS( -300.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 990   actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
 991   DALI_TEST_EQUALS( 500.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 992
 993   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
 994   std::string stringValue;
 995   actor.GetProperty( CameraActor::Property::PROJECTION_MODE ).Get( stringValue );
 996   DALI_TEST_EQUALS( stringValue, "ORTHOGRAPHIC_PROJECTION", TEST_LOCATION );
 997   END_TEST;
 998 }
 999
1000 int UtcDaliCameraActorSetProjectionModeP(void)
1001 {
1002   TestApplication application;
1003   tet_infoline( "Testing Dali::CameraActor::SetProjectionModeP (P)" );
1004
1005   CameraActor actor = CameraActor::New();
1006
1007   // Check that changing the projection mode alone does not alter other presets.
1008   actor.SetNearClippingPlane( 200.0f );
1009   actor.SetFarClippingPlane( 400.0f );
1010
1011   actor.SetProjectionMode( Dali::Camera::PERSPECTIVE_PROJECTION );
1012
1013   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1014   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION );
1015   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION );
1016
1017   actor.SetProjectionMode( Dali::Camera::ORTHOGRAPHIC_PROJECTION );
1018
1019   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
1020   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION );
1021   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION );
1022
1023   // Check setting the property.
1024   Property::Value setValue = "PERSPECTIVE_PROJECTION";
1025   actor.SetProperty( CameraActor::Property::PROJECTION_MODE, setValue );
1026   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1027   END_TEST;
1028 }
1029
1030 int UtcDaliCameraActorSetProjectionModeN(void)
1031 {
1032   TestApplication application;
1033   tet_infoline( "Testing Dali::CameraActor::SetProjectionModeP (N)" );
1034
1035   CameraActor actor;
1036
1037   bool asserted = true;
1038   try
1039   {
1040     actor.SetProjectionMode( Dali::Camera::PERSPECTIVE_PROJECTION );
1041   }
1042   catch( Dali::DaliException& e )
1043   {
1044     DALI_TEST_PRINT_ASSERT( e );
1045     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
1046     asserted = true;
1047   }
1048   DALI_TEST_CHECK( asserted );
1049   END_TEST;
1050 }
1051
1052 int UtcDaliCameraActorGetProjectionModeP(void)
1053 {
1054   TestApplication application;
1055   tet_infoline( "Testing Dali::CameraActor::GetPerspectiveProjection (P)" );
1056
1057   CameraActor actor = CameraActor::New();
1058
1059   actor.SetOrthographicProjection( Size::ONE );
1060   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
1061
1062   actor.SetPerspectiveProjection( Size( 100.f, 150.f ) );
1063   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1064
1065   // Check getting the property.
1066   std::string stringValue;
1067   actor.GetProperty( CameraActor::Property::PROJECTION_MODE ).Get( stringValue );
1068   DALI_TEST_EQUALS( stringValue, "PERSPECTIVE_PROJECTION", TEST_LOCATION );
1069   END_TEST;
1070 }
1071
1072 int UtcDaliCameraActorGetProjectionModeN(void)
1073 {
1074   TestApplication application;
1075   tet_infoline( "Testing Dali::CameraActor::GetProjectionMode (N)" );
1076
1077   CameraActor actor;
1078
1079   bool asserted = true;
1080   try
1081   {
1082     actor.GetProjectionMode();
1083   }
1084   catch( Dali::DaliException& e )
1085   {
1086     DALI_TEST_PRINT_ASSERT( e );
1087     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
1088     asserted = true;
1089   }
1090   DALI_TEST_CHECK( asserted );
1091   END_TEST;
1092 }
1093
1094 int UtcDaliCameraActorSetCameraOffStage(void)
1095 {
1096   TestApplication application;
1097   tet_infoline( "Testing Dali::CameraActor::SetCamera()" );
1098
1099   CameraActor actor = CameraActor::New();
1100
1101   actor.SetType( Camera::FREE_LOOK );
1102   actor.SetFieldOfView( TEST_FIELD_OF_VIEW );
1103   actor.SetAspectRatio( TEST_ASPECT_RATIO );
1104   actor.SetNearClippingPlane( TEST_NEAR_PLANE_DISTANCE );
1105   actor.SetFarClippingPlane( TEST_FAR_PLANE_DISTANCE );
1106   actor.SetProjectionMode( Camera::PERSPECTIVE_PROJECTION );
1107
1108   actor.SetInvertYAxis( false );
1109
1110   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION );//change to machine epsilon
1111   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION );
1112   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1113   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1114   DALI_TEST_EQUALS( Camera::PERSPECTIVE_PROJECTION, actor.GetProjectionMode(), TEST_LOCATION );
1115   DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
1116
1117   float value;
1118   std::string sValue;
1119   actor.GetProperty( CameraActor::Property::ASPECT_RATIO).Get( value );
1120   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, value, FLOAT_EPSILON, TEST_LOCATION );
1121   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW).Get( value );
1122   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, value, FLOAT_EPSILON, TEST_LOCATION );
1123   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE).Get( value );
1124   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
1125   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE).Get( value );
1126   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
1127   actor.GetProperty( CameraActor::Property::PROJECTION_MODE).Get( sValue );
1128   DALI_TEST_EQUALS( "PERSPECTIVE_PROJECTION", sValue, TEST_LOCATION );
1129   bool bValue;
1130   actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS).Get( bValue );
1131   DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
1132   END_TEST;
1133 }
1134
1135 int UtcDaliCameraActorSetCameraOnStage(void)
1136 {
1137   TestApplication application;
1138   tet_infoline( "Testing Dali::CameraActor::SetCamera()" );
1139
1140   CameraActor actor = CameraActor::New();
1141   Stage::GetCurrent().Add( actor );
1142   application.Render( 0 );
1143   application.SendNotification();
1144
1145   actor.SetType( Camera::LOOK_AT_TARGET );
1146   actor.SetFieldOfView( TEST_FIELD_OF_VIEW );
1147   actor.SetAspectRatio( TEST_ASPECT_RATIO );
1148   actor.SetNearClippingPlane( TEST_NEAR_PLANE_DISTANCE );
1149   actor.SetFarClippingPlane( TEST_FAR_PLANE_DISTANCE );
1150   actor.SetInvertYAxis( false );
1151
1152   DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
1153
1154   // Will need 2 frames to ensure both buffers are set to same values:
1155   application.Render();
1156   application.SendNotification();
1157   application.Render();
1158   application.SendNotification();
1159
1160   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION );
1161   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION );
1162   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1163   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1164   DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
1165
1166   std::string sValue;
1167   actor.GetProperty( CameraActor::Property::TYPE ).Get( sValue );
1168   DALI_TEST_EQUALS( sValue, "LOOK_AT_TARGET", TEST_LOCATION );
1169
1170   float value;
1171   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
1172   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, value, FLOAT_EPSILON, TEST_LOCATION );
1173   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
1174   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, value, FLOAT_EPSILON, TEST_LOCATION );
1175   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
1176   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
1177   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value);
1178   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
1179
1180   bool bValue;
1181   actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS ).Get( bValue );
1182   DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
1183   END_TEST;
1184 }
1185
1186 int UtcDaliCameraActorGetCamera(void)
1187 {
1188   TestApplication application;
1189   tet_infoline( "Testing Dali::CameraActor::GetCamera()" );
1190
1191   CameraActor actor = CameraActor::New();
1192
1193   actor.SetAspectRatio( TEST_ASPECT_RATIO );
1194
1195   DALI_TEST_EQUALS( actor.GetAspectRatio(), TEST_ASPECT_RATIO, FLOAT_EPSILON, TEST_LOCATION );
1196
1197   actor.SetProperty( CameraActor::Property::TYPE, "FREE_LOOK" );
1198   actor.SetProperty( CameraActor::Property::ASPECT_RATIO, TEST_ASPECT_RATIO );
1199   actor.SetProperty( CameraActor::Property::FIELD_OF_VIEW, TEST_FIELD_OF_VIEW );
1200   actor.SetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE, TEST_NEAR_PLANE_DISTANCE );
1201   actor.SetProperty( CameraActor::Property::FAR_PLANE_DISTANCE, TEST_FAR_PLANE_DISTANCE );
1202
1203   DALI_TEST_EQUALS( Camera::FREE_LOOK, actor.GetType(), TEST_LOCATION );
1204   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION );
1205   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION );
1206   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1207   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1208   END_TEST;
1209 }
1210
1211 int UtcDaliCameraActorDefaultProperties(void)
1212 {
1213   TestApplication application;
1214   tet_infoline( "Testing Dali::CameraActor DefaultProperties" );
1215
1216   CameraActor actor = CameraActor::New();
1217   Stage stage = Stage::GetCurrent();
1218   stage.Add(actor);
1219   stage.GetRenderTaskList().GetTask(0).SetCameraActor( actor );
1220
1221   actor.SetAspectRatio( TEST_ASPECT_RATIO );
1222   Stage::GetCurrent().Add( actor );
1223   application.Render( 0 );
1224   application.SendNotification();
1225   bool bValue;
1226   actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS ).Get( bValue );
1227   DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
1228
1229   std::vector<Property::Index> indices ;
1230   indices.push_back( CameraActor::Property::TYPE );
1231   indices.push_back( CameraActor::Property::PROJECTION_MODE );
1232   indices.push_back( CameraActor::Property::FIELD_OF_VIEW );
1233   indices.push_back( CameraActor::Property::ASPECT_RATIO );
1234   indices.push_back( CameraActor::Property::NEAR_PLANE_DISTANCE );
1235   indices.push_back( CameraActor::Property::FAR_PLANE_DISTANCE );
1236   indices.push_back( CameraActor::Property::LEFT_PLANE_DISTANCE );
1237   indices.push_back( CameraActor::Property::RIGHT_PLANE_DISTANCE );
1238   indices.push_back( CameraActor::Property::TOP_PLANE_DISTANCE );
1239   indices.push_back( CameraActor::Property::BOTTOM_PLANE_DISTANCE );
1240   indices.push_back( CameraActor::Property::TARGET_POSITION );
1241   indices.push_back( CameraActor::Property::PROJECTION_MATRIX );
1242   indices.push_back( CameraActor::Property::VIEW_MATRIX );
1243   indices.push_back( CameraActor::Property::INVERT_Y_AXIS );
1244
1245   DALI_TEST_CHECK( actor.GetPropertyCount() == ( Actor::New().GetPropertyCount() + indices.size() ) );
1246
1247   for( std::vector<Property::Index>::iterator iter = indices.begin(); iter != indices.end(); ++iter )
1248   {
1249     DALI_TEST_EQUALS( *iter, actor.GetPropertyIndex( actor.GetPropertyName( *iter ) ), TEST_LOCATION);
1250     DALI_TEST_CHECK( !actor.IsPropertyAnimatable( *iter ) );
1251
1252     if ( ( *iter == CameraActor::Property::PROJECTION_MATRIX ) ||
1253          ( *iter == CameraActor::Property::VIEW_MATRIX ) )
1254     {
1255       DALI_TEST_CHECK( !actor.IsPropertyWritable( *iter ) );
1256     }
1257     else
1258     {
1259       DALI_TEST_CHECK( actor.IsPropertyWritable( *iter ) );
1260     }
1261
1262     DALI_TEST_CHECK( actor.GetPropertyType( *iter ) == actor.GetPropertyType( *iter ) ); // just checking call succeeds
1263   }
1264
1265   // Set/Get one of them.
1266   const float newAspect = TEST_ASPECT_RATIO * 2.0f;
1267
1268   actor.SetProperty( CameraActor::Property::ASPECT_RATIO, Property::Value( newAspect ) );
1269   application.Render();
1270   application.SendNotification();
1271   application.Render();
1272   application.SendNotification();
1273
1274   DALI_TEST_EQUALS( actor.GetAspectRatio(), newAspect, TEST_LOCATION );
1275   END_TEST;
1276 }
1277
1278 template< typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
1279 void TEST_CAMERA_PROPERTY( P1 camera, P2 stringName, P3 type, P4 isWriteable, P5 isAnimateable, P6 isConstraintInput, P7 enumName, P8 LOCATION )
1280 {
1281   DALI_TEST_EQUALS( camera.GetPropertyName( enumName ), stringName, LOCATION );
1282   DALI_TEST_EQUALS( camera.GetPropertyIndex( stringName ), static_cast<Property::Index>(enumName), LOCATION );
1283   DALI_TEST_EQUALS( camera.GetPropertyType( enumName ), type, LOCATION );
1284   DALI_TEST_EQUALS( camera.IsPropertyWritable( enumName ), isWriteable, LOCATION );
1285   DALI_TEST_EQUALS( camera.IsPropertyAnimatable( enumName ), isAnimateable, LOCATION );
1286   DALI_TEST_EQUALS( camera.IsPropertyAConstraintInput( enumName ), isConstraintInput, LOCATION );
1287 }
1288 int UtcDaliCameraActorDefaultPropertiesInherited(void)
1289 {
1290   TestApplication application;
1291
1292   CameraActor actor = CameraActor::New();
1293   Stage stage = Stage::GetCurrent();
1294   stage.Add(actor);
1295   stage.GetRenderTaskList().GetTask(0).SetCameraActor( actor );
1296
1297   Stage::GetCurrent().Add( actor );
1298   application.Render( 0 );
1299   application.SendNotification();
1300
1301   const PropertyDetails CAMERA_DEFAULT_PROPERTY[] =
1302   {
1303 // actor
1304     { "parentOrigin",           Property::VECTOR3,  true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN },
1305     { "parentOriginX",          Property::FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_X },
1306     { "parentOriginY",          Property::FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_Y },
1307     { "parentOriginZ",          Property::FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_Z },
1308     { "anchorPoint",            Property::VECTOR3,  true,  false, true,  Dali::Actor::Property::ANCHOR_POINT },
1309     { "anchorPointX",           Property::FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_X },
1310     { "anchorPointY",           Property::FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_Y },
1311     { "anchorPointZ",           Property::FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_Z },
1312     { "size",                   Property::VECTOR3,  true,  true,  true,  Dali::Actor::Property::SIZE },
1313     { "sizeWidth",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_WIDTH },
1314     { "sizeHeight",             Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_HEIGHT },
1315     { "sizeDepth",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_DEPTH },
1316     { "position",               Property::VECTOR3,  true,  true,  true,  Dali::Actor::Property::POSITION },
1317     { "positionX",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_X },
1318     { "positionY",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_Y },
1319     { "positionZ",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_Z },
1320     { "worldPosition",          Property::VECTOR3,  false, false, true,  Dali::Actor::Property::WORLD_POSITION },
1321     { "worldPositionX",         Property::FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_X },
1322     { "worldPositionY",         Property::FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_Y },
1323     { "worldPositionZ",         Property::FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_Z },
1324     { "orientation",            Property::ROTATION, true,  true,  true,  Dali::Actor::Property::ORIENTATION },
1325     { "worldOrientation",       Property::ROTATION, false, false, true,  Dali::Actor::Property::WORLD_ORIENTATION },
1326     { "scale",                  Property::VECTOR3,  true,  true,  true,  Dali::Actor::Property::SCALE },
1327     { "scaleX",                 Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_X },
1328     { "scaleY",                 Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_Y },
1329     { "scaleZ",                 Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_Z },
1330     { "worldScale",             Property::VECTOR3,  false, false, true,  Dali::Actor::Property::WORLD_SCALE },
1331     { "visible",                Property::BOOLEAN,  true,  true,  true,  Dali::Actor::Property::VISIBLE },
1332     { "color",                  Property::VECTOR4,  true,  true,  true,  Dali::Actor::Property::COLOR },
1333     { "colorRed",               Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_RED },
1334     { "colorGreen",             Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_GREEN },
1335     { "colorBlue",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_BLUE },
1336     { "colorAlpha",             Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_ALPHA },
1337     { "worldColor",             Property::VECTOR4,  false, false, true,  Dali::Actor::Property::WORLD_COLOR },
1338     { "worldMatrix",            Property::MATRIX,   false, false, true,  Dali::Actor::Property::WORLD_MATRIX },
1339     { "name",                   Property::STRING,   true,  false, false, Dali::Actor::Property::NAME },
1340     { "sensitive",              Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::SENSITIVE },
1341     { "leaveRequired",          Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::LEAVE_REQUIRED },
1342     { "inheritOrientation",     Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_ORIENTATION },
1343     { "inheritScale",           Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_SCALE },
1344     { "colorMode",              Property::STRING,   true,  false, false, Dali::Actor::Property::COLOR_MODE },
1345     { "drawMode",               Property::STRING,   true,  false, false, Dali::Actor::Property::DRAW_MODE },
1346     { "sizeModeFactor",         Property::VECTOR3,  true,  false, false, Dali::Actor::Property::SIZE_MODE_FACTOR },
1347     { "widthResizePolicy",      Property::STRING,   true,  false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY },
1348     { "heightResizePolicy",     Property::STRING,   true,  false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY },
1349     { "sizeScalePolicy",        Property::STRING,   true,  false, false, Dali::Actor::Property::SIZE_SCALE_POLICY },
1350     { "widthForHeight",         Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT },
1351     { "heightForWidth",         Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH },
1352     { "padding",                Property::VECTOR4,  true,  false, false, Dali::Actor::Property::PADDING },
1353     { "minimumSize",            Property::VECTOR2,  true,  false, false, Dali::Actor::Property::MINIMUM_SIZE },
1354     { "maximumSize",            Property::VECTOR2,  true,  false, false, Dali::Actor::Property::MAXIMUM_SIZE },
1355     { "inheritPosition",        Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_POSITION },
1356     { "clippingMode",           Property::STRING,   true,  false, false, Dali::Actor::Property::CLIPPING_MODE },
1357     { "layoutDirection",        Property::STRING,   true,  false, false, Dali::Actor::Property::LAYOUT_DIRECTION },
1358     { "inheritLayoutDirection", Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION },
1359     { "siblingOrder",           Property::INTEGER,  true,  false, false, Dali::DevelActor::Property::SIBLING_ORDER },
1360     { "opacity",                Property::FLOAT,    true,  true,  true,  Dali::DevelActor::Property::OPACITY },
1361     { "screenPosition",         Property::VECTOR2,  false, false, false, Dali::DevelActor::Property::SCREEN_POSITION },
1362     { "positionUsesAnchorPoint",Property::BOOLEAN,  true,  false, false, Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT },
1363     { "culled",                 Property::BOOLEAN,  false, false, true,  Dali::DevelActor::Property::CULLED },
1364 // camera own
1365     { "type",                   Property::STRING,   true,    false,   true,   Dali::CameraActor::Property::TYPE                  },
1366     { "projectionMode",         Property::STRING,   true,    false,   true,   Dali::CameraActor::Property::PROJECTION_MODE       },
1367     { "fieldOfView",            Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::FIELD_OF_VIEW         },
1368     { "aspectRatio",            Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::ASPECT_RATIO          },
1369     { "nearPlaneDistance",      Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::NEAR_PLANE_DISTANCE   },
1370     { "farPlaneDistance",       Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::FAR_PLANE_DISTANCE    },
1371     { "leftPlaneDistance",      Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::LEFT_PLANE_DISTANCE   },
1372     { "rightPlaneDistance",     Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE  },
1373     { "topPlaneDistance",       Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::TOP_PLANE_DISTANCE    },
1374     { "bottomPlaneDistance",    Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE },
1375     { "targetPosition",         Property::VECTOR3,  true,    false,   true,   Dali::CameraActor::Property::TARGET_POSITION       },
1376     { "projectionMatrix",       Property::MATRIX,   false,   false,   true,   Dali::CameraActor::Property::PROJECTION_MATRIX     },
1377     { "viewMatrix",             Property::MATRIX,   false,   false,   true,   Dali::CameraActor::Property::VIEW_MATRIX           },
1378     { "invertYAxis",            Property::BOOLEAN,  true,    false,   true,   Dali::CameraActor::Property::INVERT_Y_AXIS         }
1379   };
1380
1381   for( uint32_t index = 0; index < (sizeof(CAMERA_DEFAULT_PROPERTY)/sizeof(PropertyDetails)); ++index )
1382   {
1383     TEST_CAMERA_PROPERTY( actor,
1384                           CAMERA_DEFAULT_PROPERTY[ index ].name,
1385                           CAMERA_DEFAULT_PROPERTY[ index ].type,
1386                           CAMERA_DEFAULT_PROPERTY[ index ].writable,
1387                           CAMERA_DEFAULT_PROPERTY[ index ].animatable,
1388                           CAMERA_DEFAULT_PROPERTY[ index ].constraintInput,
1389                           CAMERA_DEFAULT_PROPERTY[ index ].enumIndex,
1390                           TEST_LOCATION );
1391   }
1392   END_TEST;
1393 }
1394
1395 int UtcDaliCameraActorModelView(void)
1396 {
1397   TestApplication application;
1398   tet_infoline( "Testing Dali::CameraActor Test view application" );
1399
1400   BufferImage image = CreateBufferImage();
1401
1402   Actor actor = CreateRenderableActor(image);
1403   actor.SetSize( 100.0f, 100.0f );
1404   actor.SetPosition( 20.0f, 30.0f, 40.0f );
1405   actor.SetParentOrigin( ParentOrigin::CENTER );
1406   Stage::GetCurrent().Add( actor );
1407
1408   application.SendNotification();
1409   application.Render( 0 );
1410   application.Render();
1411   application.SendNotification();
1412
1413   Matrix resultMatrix( true );
1414   resultMatrix.SetTransformComponents( Vector3::ONE, Quaternion::IDENTITY, actor.GetCurrentPosition() );
1415
1416   RenderTask task = Stage::GetCurrent().GetRenderTaskList().GetTask( 0 );
1417   CameraActor cameraActor = task.GetCameraActor();
1418
1419   Matrix viewMatrix( false );
1420   cameraActor.GetProperty( CameraActor::Property::VIEW_MATRIX ).Get( viewMatrix );
1421   Matrix::Multiply( resultMatrix, resultMatrix, viewMatrix );
1422
1423   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( "uModelView", resultMatrix ) );
1424   END_TEST;
1425 }
1426
1427 int UtcDaliCameraActorReadProjectionMatrix(void)
1428 {
1429   TestApplication application;
1430   tet_infoline( "Testing Dali::CameraActor::ReadProjectionMatrix()" );
1431
1432   CameraActor camera = Stage::GetCurrent().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
1433   application.SendNotification();
1434   application.Render( 0 );
1435   application.Render();
1436   application.SendNotification();
1437   Image image = CreateBufferImage();
1438   Actor actor = CreateRenderableActor( image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE );
1439   actor.SetSize( 100.0f, 100.0f );
1440   Stage::GetCurrent().Add( actor );
1441
1442   Matrix projectionMatrix;
1443   Matrix viewMatrix;
1444
1445   camera.GetProperty( CameraActor::CameraActor::Property::PROJECTION_MATRIX ).Get( projectionMatrix );
1446   camera.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( viewMatrix );
1447
1448   actor.RegisterProperty( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
1449   actor.RegisterProperty( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
1450
1451   Property::Index projectionMatrixPropertyIndex = actor.GetPropertyIndex( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME );
1452   Property::Index viewMatrixPropertyIndex = actor.GetPropertyIndex( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME );
1453
1454   Constraint projectionMatrixConstraint = Constraint::New<Dali::Matrix>( actor, projectionMatrixPropertyIndex, EqualToConstraint() );
1455   projectionMatrixConstraint.AddSource( Source( camera, CameraActor::Property::PROJECTION_MATRIX ) );
1456   Constraint viewMatrixConstraint = Constraint::New<Dali::Matrix>( actor, viewMatrixPropertyIndex, EqualToConstraint() );
1457   viewMatrixConstraint.AddSource( Source( camera, CameraActor::Property::VIEW_MATRIX ) );
1458
1459   projectionMatrixConstraint.Apply();
1460   viewMatrixConstraint.Apply();
1461
1462   application.SendNotification();
1463   application.Render();
1464
1465   // Test effects of Constraint.
1466   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME.c_str(), projectionMatrix) );
1467
1468   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME.c_str(), viewMatrix ) );
1469   END_TEST;
1470 }
1471
1472 int UtcDaliCameraActorAnimatedProperties(void)
1473 {
1474   TestApplication application;
1475   tet_infoline( "Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()" );
1476
1477   CameraActor camera = Stage::GetCurrent().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
1478   Actor actor = Actor::New();
1479   actor.SetSize( 100.0f, 100.0f );
1480   Stage::GetCurrent().Add( actor );
1481
1482   Constraint constraint = Constraint::New<Dali::Vector3>( actor, Actor::Property::POSITION, EqualToConstraint() );
1483   constraint.AddSource( Source( camera, Actor::Property::POSITION ) );
1484   constraint.Apply();
1485
1486   camera.SetPosition( 100.0f, 200.0f, 300.0f );
1487   application.SendNotification();
1488   application.Render();
1489
1490   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3( 100.0f, 200.0f, 300.0f ), TEST_LOCATION);
1491   END_TEST;
1492 }
1493
1494 int UtcDaliCameraActorPropertyIndices(void)
1495 {
1496   TestApplication application;
1497   CameraActor camera = Stage::GetCurrent().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
1498
1499   Actor basicActor = Actor::New();
1500   Property::IndexContainer indices;
1501   camera.GetPropertyIndices( indices );
1502   DALI_TEST_CHECK( indices.Size() > basicActor.GetPropertyCount() );
1503   DALI_TEST_EQUALS( indices.Size(), camera.GetPropertyCount(), TEST_LOCATION );
1504   END_TEST;
1505 }
1506
1507 int UtcDaliCameraActorCheckLookAtAndFreeLookViews01(void)
1508 {
1509   TestApplication application;
1510   Stage stage = Stage::GetCurrent();
1511   Vector2 stageSize = stage.GetSize();
1512
1513   CameraActor freeLookCameraActor = CameraActor::New( stageSize );
1514   freeLookCameraActor.SetParentOrigin( ParentOrigin::CENTER );
1515   freeLookCameraActor.SetType( Camera::FREE_LOOK );
1516
1517   Vector3 targetPosition( 30.0f, 240.0f, -256.0f );
1518   Actor target = Actor::New();
1519   target.SetParentOrigin( ParentOrigin::CENTER );
1520   target.SetPosition( targetPosition );
1521
1522   Constraint cameraOrientationConstraint = Constraint::New<Quaternion> ( freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt );
1523   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_POSITION ) );
1524   cameraOrientationConstraint.AddSource( Source( freeLookCameraActor,  Actor::Property::WORLD_POSITION ) );
1525   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_ORIENTATION ) );
1526   cameraOrientationConstraint.Apply();
1527
1528   CameraActor lookAtCameraActor = CameraActor::New( stageSize );
1529   lookAtCameraActor.SetType( Camera::LOOK_AT_TARGET );
1530   lookAtCameraActor.SetTargetPosition( targetPosition );
1531   lookAtCameraActor.SetParentOrigin( ParentOrigin::CENTER );
1532
1533   stage.Add( target );
1534   stage.Add( freeLookCameraActor );
1535   stage.Add( lookAtCameraActor );
1536
1537   // Create an arbitrary vector
1538   for( float x=-1.0f; x<=1.0f; x+=0.1f )
1539   {
1540     for( float y=-1.0f; y<1.0f; y+=0.1f )
1541     {
1542       for( float z=-1.0f; z<1.0f; z+=0.1f )
1543       {
1544         Vector3 position( x, y, z );
1545         position.Normalize();
1546         position *= 200.0f;
1547
1548         freeLookCameraActor.SetPosition( position );
1549         lookAtCameraActor.SetPosition( position );
1550
1551         application.SendNotification();
1552         application.Render();
1553         application.SendNotification();
1554         application.Render();
1555         Matrix freeLookViewMatrix;
1556         Matrix lookAtViewMatrix;
1557         freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
1558         lookAtCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( lookAtViewMatrix );
1559
1560         DALI_TEST_EQUALS( freeLookViewMatrix, lookAtViewMatrix, 0.01, TEST_LOCATION );
1561       }
1562     }
1563   }
1564   END_TEST;
1565 }
1566
1567 int UtcDaliCameraActorCheckLookAtAndFreeLookViews02(void)
1568 {
1569   TestApplication application;
1570   Stage stage = Stage::GetCurrent();
1571   Vector2 stageSize = stage.GetSize();
1572
1573   CameraActor freeLookCameraActor = CameraActor::New( stageSize );
1574   freeLookCameraActor.SetParentOrigin( ParentOrigin::CENTER );
1575   freeLookCameraActor.SetType( Camera::FREE_LOOK );
1576
1577   Vector3 targetPosition( 30.0f, 240.0f, -256.0f );
1578   Actor target = Actor::New();
1579   target.SetParentOrigin( ParentOrigin::CENTER );
1580   target.SetPosition( targetPosition );
1581
1582   Constraint cameraOrientationConstraint = Constraint::New<Quaternion> ( freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt );
1583   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_POSITION ) );
1584   cameraOrientationConstraint.AddSource( Source( freeLookCameraActor,  Actor::Property::WORLD_POSITION ) );
1585   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_ORIENTATION ) );
1586   cameraOrientationConstraint.Apply();
1587
1588   CameraActor lookAtCameraActor = CameraActor::New( stageSize );
1589   lookAtCameraActor.SetType( Camera::LOOK_AT_TARGET );
1590   lookAtCameraActor.SetTargetPosition( targetPosition );
1591   lookAtCameraActor.SetParentOrigin( ParentOrigin::CENTER );
1592
1593   stage.Add( target );
1594   stage.Add( freeLookCameraActor );
1595   stage.Add( lookAtCameraActor );
1596   stage.GetRenderTaskList().GetTask(0).SetCameraActor( freeLookCameraActor );
1597
1598   // Create an arbitrary vector
1599   for( float x=-1.0f; x<=1.0f; x+=0.1f )
1600   {
1601     for( float y=-1.0f; y<1.0f; y+=0.1f )
1602     {
1603       for( float z=-1.0f; z<1.0f; z+=0.1f )
1604       {
1605         Vector3 position( x, y, z );
1606         position.Normalize();
1607         position *= 200.0f;
1608
1609         freeLookCameraActor.SetPosition( position );
1610         lookAtCameraActor.SetPosition( position );
1611
1612         application.SendNotification();
1613         application.Render();
1614         application.SendNotification();
1615         application.Render();
1616         Matrix freeLookViewMatrix;
1617         freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
1618
1619         Matrix freeLookWorld = freeLookCameraActor.GetCurrentWorldMatrix();
1620
1621         Matrix freeLookTest( false );
1622         Matrix::Multiply( freeLookTest, freeLookViewMatrix, freeLookWorld );
1623         DALI_TEST_EQUALS( freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION );
1624       }
1625     }
1626   }
1627
1628   END_TEST;
1629 }
1630
1631 int UtcDaliCameraActorCheckLookAtAndFreeLookViews03(void)
1632 {
1633   TestApplication application;
1634   Stage stage = Stage::GetCurrent();
1635   Vector2 stageSize = stage.GetSize();
1636
1637   Vector3 targetPosition( Vector3::ZERO );
1638   Vector3 cameraOffset( 0.0f, 0.0f, 100.0f );
1639
1640   CameraActor freeLookCameraActor = CameraActor::New( stageSize );
1641   freeLookCameraActor.SetType( Camera::FREE_LOOK );
1642   freeLookCameraActor.SetParentOrigin( ParentOrigin::CENTER );
1643
1644   Quaternion cameraOrientation( Radian( Degree( 180.0f ) ), Vector3::YAXIS );
1645   freeLookCameraActor.SetPosition( cameraOffset );
1646   freeLookCameraActor.SetOrientation( cameraOrientation );
1647
1648   Actor cameraAnchor = Actor::New();
1649   cameraAnchor.Add( freeLookCameraActor );
1650   stage.Add( cameraAnchor );
1651   stage.GetRenderTaskList().GetTask(0).SetCameraActor( freeLookCameraActor );
1652
1653   for( float angle = 1.0f; angle <= 180.0f; angle += 1.0f )
1654   {
1655     Quaternion rotation( Radian( Degree( angle ) ), Vector3::YAXIS );
1656
1657     freeLookCameraActor.SetPosition( rotation.Rotate( cameraOffset ) );
1658     cameraAnchor.SetOrientation( rotation );
1659
1660     application.SendNotification();
1661     application.Render();
1662     application.SendNotification();
1663     application.Render();
1664
1665     Matrix freeLookViewMatrix;
1666     freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
1667
1668     Matrix freeLookWorld = freeLookCameraActor.GetCurrentWorldMatrix();
1669
1670     Matrix freeLookTest( false );
1671     Matrix::Multiply( freeLookTest,  freeLookViewMatrix,  freeLookWorld );
1672     DALI_TEST_EQUALS( freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION );
1673   }
1674   END_TEST;
1675 }