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();
 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();
 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();
 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();
 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();
 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();
 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   Stage stage = Stage::GetCurrent();
 809   Vector2 stageSize = stage.GetSize();
 810
 811   CameraActor actor = CameraActor::New();
 812
 813   // Check that setting perspective projection without a size (using zero size) uses the stages size.
 814   actor.SetPerspectiveProjection( Size::ZERO );
 815
 816   float nearClippingPlane = std::max( stageSize.width, stageSize.height );
 817   float farClippingPlane = nearClippingPlane + static_cast<float>( 0xFFFF >> 4 );
 818
 819   DALI_TEST_EQUALS( nearClippingPlane, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
 820   DALI_TEST_EQUALS( farClippingPlane, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
 821   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
 822
 823   END_TEST;
 824 }
 825
 826 int UtcDaliCameraActorSetOrthographicProjectionP1(void)
 827 {
 828   TestApplication application;
 829   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,1)" );
 830
 831   CameraActor actor = CameraActor::New( Size( 1080.0f, 1920.0f ) );
 832   DALI_TEST_CHECK( actor );
 833
 834   Stage::GetCurrent().Add( actor );
 835
 836   actor.SetOrthographicProjection( Size( 1080.0f, 1920.0f ) );
 837   application.SendNotification();
 838   application.Render( 0 );
 839   application.Render();
 840   application.SendNotification();
 841
 842   float defaultAspectRatio;
 843   float defaultFieldOfView;
 844   float defaultNearPlaneDistance;
 845   float defaultFarPlaneDistance;
 846   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
 847   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
 848   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
 849   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
 850   Vector3 defaultPos = actor.GetCurrentPosition();
 851
 852   actor.SetOrthographicProjection( Size( 1080.0f, 1920.0f ) );
 853
 854   application.SendNotification();
 855   application.Render( 0 );
 856   application.Render();
 857   application.SendNotification();
 858
 859   float value;
 860   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 861   DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
 862   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 863   DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 864   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 865   DALI_TEST_EQUALS( defaultNearPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION );
 866   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 867   DALI_TEST_EQUALS( defaultFarPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION );
 868
 869   actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
 870   DALI_TEST_EQUALS( -540.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 871   actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
 872   DALI_TEST_EQUALS( 540.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 873   actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
 874   DALI_TEST_EQUALS( 960.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 875   actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
 876   DALI_TEST_EQUALS( -960.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 877
 878   Vector3 pos = actor.GetCurrentPosition();
 879   DALI_TEST_EQUALS( defaultPos.z, pos.z, 0.001f, TEST_LOCATION );
 880
 881   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
 882   END_TEST;
 883 }
 884
 885 int UtcDaliCameraActorSetOrthographicProjectionN(void)
 886 {
 887   TestApplication application;
 888   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (N)" );
 889
 890   CameraActor actor;
 891   bool asserted = true;
 892   try
 893   {
 894     actor.GetProjectionMode();
 895   }
 896   catch( Dali::DaliException& e )
 897   {
 898     DALI_TEST_PRINT_ASSERT( e );
 899     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
 900     asserted = true;
 901   }
 902   DALI_TEST_CHECK( asserted );
 903   END_TEST;
 904 }
 905
 906 int UtcDaliCameraActorSetOrthographicProjectionP2(void)
 907 {
 908   TestApplication application;
 909   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,2)" );
 910
 911   CameraActor actor = CameraActor::New();
 912   DALI_TEST_CHECK( actor );
 913
 914   float defaultAspectRatio;
 915   float defaultFieldOfView;
 916   float defaultNearPlaneDistance;
 917   float defaultFarPlaneDistance;
 918   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
 919   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
 920   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
 921   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
 922
 923   // Check setting with specific near and far plane distances.
 924   actor.SetOrthographicProjection( -100.0f, 200.0f, -300.0f, 500.0f, 400.0f, 4000.0f );
 925
 926   float value;
 927   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 928   DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
 929   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 930   DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 931   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 932   DALI_TEST_EQUALS( 400.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 933   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 934   DALI_TEST_EQUALS( 4000.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 935
 936   actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
 937   DALI_TEST_EQUALS( -100.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 938   actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
 939   DALI_TEST_EQUALS( 200.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 940   actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
 941   DALI_TEST_EQUALS( -300.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 942   actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
 943   DALI_TEST_EQUALS( 500.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 944
 945   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
 946
 947   END_TEST;
 948 }
 949
 950 int UtcDaliCameraActorSetOrthographicProjectionP3(void)
 951 {
 952   TestApplication application;
 953   tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,3)" );
 954
 955   CameraActor actor = CameraActor::New();
 956   DALI_TEST_CHECK( actor );
 957
 958   float defaultAspectRatio;
 959   float defaultFieldOfView;
 960   float defaultNearPlaneDistance;
 961   float defaultFarPlaneDistance;
 962   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
 963   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
 964   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
 965   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
 966
 967   actor.SetProjectionMode( Dali::Camera::ORTHOGRAPHIC_PROJECTION );
 968
 969   actor.SetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE, -100.0f );
 970   actor.SetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE, 200.0f );
 971   actor.SetProperty( CameraActor::Property::TOP_PLANE_DISTANCE, -300.0f );
 972   actor.SetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE, 500.0f );
 973   actor.SetNearClippingPlane( 400.0f );
 974   actor.SetFarClippingPlane( 4000.0f );
 975
 976   float value;
 977   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
 978   DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
 979   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
 980   DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
 981   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
 982   DALI_TEST_EQUALS( 400.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 983   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
 984   DALI_TEST_EQUALS( 4000.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 985
 986   actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
 987   DALI_TEST_EQUALS( -100.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 988   actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
 989   DALI_TEST_EQUALS( 200.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 990   actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
 991   DALI_TEST_EQUALS( -300.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 992   actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
 993   DALI_TEST_EQUALS( 500.0f, value, FLOAT_EPSILON, TEST_LOCATION );
 994
 995   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
 996   std::string stringValue;
 997   actor.GetProperty( CameraActor::Property::PROJECTION_MODE ).Get( stringValue );
 998   DALI_TEST_EQUALS( stringValue, "ORTHOGRAPHIC_PROJECTION", TEST_LOCATION );
 999   END_TEST;
1000 }
1001
1002 int UtcDaliCameraActorSetProjectionModeP(void)
1003 {
1004   TestApplication application;
1005   tet_infoline( "Testing Dali::CameraActor::SetProjectionModeP (P)" );
1006
1007   CameraActor actor = CameraActor::New();
1008
1009   // Check that changing the projection mode alone does not alter other presets.
1010   actor.SetNearClippingPlane( 200.0f );
1011   actor.SetFarClippingPlane( 400.0f );
1012
1013   actor.SetProjectionMode( Dali::Camera::PERSPECTIVE_PROJECTION );
1014
1015   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1016   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION );
1017   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION );
1018
1019   actor.SetProjectionMode( Dali::Camera::ORTHOGRAPHIC_PROJECTION );
1020
1021   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
1022   DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION );
1023   DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION );
1024
1025   // Check setting the property.
1026   Property::Value setValue = "PERSPECTIVE_PROJECTION";
1027   actor.SetProperty( CameraActor::Property::PROJECTION_MODE, setValue );
1028   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1029   END_TEST;
1030 }
1031
1032 int UtcDaliCameraActorSetProjectionModeN(void)
1033 {
1034   TestApplication application;
1035   tet_infoline( "Testing Dali::CameraActor::SetProjectionModeP (N)" );
1036
1037   CameraActor actor;
1038
1039   bool asserted = true;
1040   try
1041   {
1042     actor.SetProjectionMode( Dali::Camera::PERSPECTIVE_PROJECTION );
1043   }
1044   catch( Dali::DaliException& e )
1045   {
1046     DALI_TEST_PRINT_ASSERT( e );
1047     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
1048     asserted = true;
1049   }
1050   DALI_TEST_CHECK( asserted );
1051   END_TEST;
1052 }
1053
1054 int UtcDaliCameraActorGetProjectionModeP(void)
1055 {
1056   TestApplication application;
1057   tet_infoline( "Testing Dali::CameraActor::GetPerspectiveProjection (P)" );
1058
1059   CameraActor actor = CameraActor::New();
1060
1061   actor.SetOrthographicProjection( Size::ONE );
1062   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
1063
1064   actor.SetPerspectiveProjection( Size( 100.f, 150.f ) );
1065   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1066
1067   // Check getting the property.
1068   std::string stringValue;
1069   actor.GetProperty( CameraActor::Property::PROJECTION_MODE ).Get( stringValue );
1070   DALI_TEST_EQUALS( stringValue, "PERSPECTIVE_PROJECTION", TEST_LOCATION );
1071   END_TEST;
1072 }
1073
1074 int UtcDaliCameraActorGetProjectionModeN(void)
1075 {
1076   TestApplication application;
1077   tet_infoline( "Testing Dali::CameraActor::GetProjectionMode (N)" );
1078
1079   CameraActor actor;
1080
1081   bool asserted = true;
1082   try
1083   {
1084     actor.GetProjectionMode();
1085   }
1086   catch( Dali::DaliException& e )
1087   {
1088     DALI_TEST_PRINT_ASSERT( e );
1089     DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
1090     asserted = true;
1091   }
1092   DALI_TEST_CHECK( asserted );
1093   END_TEST;
1094 }
1095
1096 int UtcDaliCameraActorSetCameraOffStage(void)
1097 {
1098   TestApplication application;
1099   tet_infoline( "Testing Dali::CameraActor::SetCamera()" );
1100
1101   CameraActor actor = CameraActor::New();
1102
1103   actor.SetType( Camera::FREE_LOOK );
1104   actor.SetFieldOfView( TEST_FIELD_OF_VIEW );
1105   actor.SetAspectRatio( TEST_ASPECT_RATIO );
1106   actor.SetNearClippingPlane( TEST_NEAR_PLANE_DISTANCE );
1107   actor.SetFarClippingPlane( TEST_FAR_PLANE_DISTANCE );
1108   actor.SetProjectionMode( Camera::PERSPECTIVE_PROJECTION );
1109
1110   actor.SetInvertYAxis( false );
1111
1112   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION );//change to machine epsilon
1113   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION );
1114   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1115   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1116   DALI_TEST_EQUALS( Camera::PERSPECTIVE_PROJECTION, actor.GetProjectionMode(), TEST_LOCATION );
1117   DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
1118
1119   float value;
1120   std::string sValue;
1121   actor.GetProperty( CameraActor::Property::ASPECT_RATIO).Get( value );
1122   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, value, FLOAT_EPSILON, TEST_LOCATION );
1123   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW).Get( value );
1124   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, value, FLOAT_EPSILON, TEST_LOCATION );
1125   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE).Get( value );
1126   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
1127   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE).Get( value );
1128   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
1129   actor.GetProperty( CameraActor::Property::PROJECTION_MODE).Get( sValue );
1130   DALI_TEST_EQUALS( "PERSPECTIVE_PROJECTION", sValue, TEST_LOCATION );
1131   bool bValue;
1132   actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS).Get( bValue );
1133   DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
1134   END_TEST;
1135 }
1136
1137 int UtcDaliCameraActorSetCameraOnStage(void)
1138 {
1139   TestApplication application;
1140   tet_infoline( "Testing Dali::CameraActor::SetCamera()" );
1141
1142   CameraActor actor = CameraActor::New();
1143   Stage::GetCurrent().Add( actor );
1144   application.Render( 0 );
1145   application.SendNotification();
1146
1147   actor.SetType( Camera::LOOK_AT_TARGET );
1148   actor.SetFieldOfView( TEST_FIELD_OF_VIEW );
1149   actor.SetAspectRatio( TEST_ASPECT_RATIO );
1150   actor.SetNearClippingPlane( TEST_NEAR_PLANE_DISTANCE );
1151   actor.SetFarClippingPlane( TEST_FAR_PLANE_DISTANCE );
1152   actor.SetInvertYAxis( false );
1153
1154   DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
1155
1156   // Will need 2 frames to ensure both buffers are set to same values:
1157   application.Render();
1158   application.SendNotification();
1159   application.Render();
1160   application.SendNotification();
1161
1162   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION );
1163   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION );
1164   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1165   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1166   DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
1167
1168   std::string sValue;
1169   actor.GetProperty( CameraActor::Property::TYPE ).Get( sValue );
1170   DALI_TEST_EQUALS( sValue, "LOOK_AT_TARGET", TEST_LOCATION );
1171
1172   float value;
1173   actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
1174   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, value, FLOAT_EPSILON, TEST_LOCATION );
1175   actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
1176   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, value, FLOAT_EPSILON, TEST_LOCATION );
1177   actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
1178   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
1179   actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value);
1180   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
1181
1182   bool bValue;
1183   actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS ).Get( bValue );
1184   DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
1185   END_TEST;
1186 }
1187
1188 int UtcDaliCameraActorGetCamera(void)
1189 {
1190   TestApplication application;
1191   tet_infoline( "Testing Dali::CameraActor::GetCamera()" );
1192
1193   CameraActor actor = CameraActor::New();
1194
1195   actor.SetAspectRatio( TEST_ASPECT_RATIO );
1196
1197   DALI_TEST_EQUALS( actor.GetAspectRatio(), TEST_ASPECT_RATIO, FLOAT_EPSILON, TEST_LOCATION );
1198
1199   actor.SetProperty( CameraActor::Property::TYPE, "FREE_LOOK" );
1200   actor.SetProperty( CameraActor::Property::ASPECT_RATIO, TEST_ASPECT_RATIO );
1201   actor.SetProperty( CameraActor::Property::FIELD_OF_VIEW, TEST_FIELD_OF_VIEW );
1202   actor.SetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE, TEST_NEAR_PLANE_DISTANCE );
1203   actor.SetProperty( CameraActor::Property::FAR_PLANE_DISTANCE, TEST_FAR_PLANE_DISTANCE );
1204
1205   DALI_TEST_EQUALS( Camera::FREE_LOOK, actor.GetType(), TEST_LOCATION );
1206   DALI_TEST_EQUALS( TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION );
1207   DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION );
1208   DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1209   DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
1210   END_TEST;
1211 }
1212
1213 int UtcDaliCameraActorDefaultProperties(void)
1214 {
1215   TestApplication application;
1216   tet_infoline( "Testing Dali::CameraActor DefaultProperties" );
1217
1218   CameraActor actor = CameraActor::New();
1219   Stage stage = Stage::GetCurrent();
1220   stage.Add(actor);
1221   stage.GetRenderTaskList().GetTask(0).SetCameraActor( actor );
1222
1223   actor.SetAspectRatio( TEST_ASPECT_RATIO );
1224   Stage::GetCurrent().Add( actor );
1225   application.Render( 0 );
1226   application.SendNotification();
1227   bool bValue;
1228   actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS ).Get( bValue );
1229   DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
1230
1231   std::vector<Property::Index> indices ;
1232   indices.push_back( CameraActor::Property::TYPE );
1233   indices.push_back( CameraActor::Property::PROJECTION_MODE );
1234   indices.push_back( CameraActor::Property::FIELD_OF_VIEW );
1235   indices.push_back( CameraActor::Property::ASPECT_RATIO );
1236   indices.push_back( CameraActor::Property::NEAR_PLANE_DISTANCE );
1237   indices.push_back( CameraActor::Property::FAR_PLANE_DISTANCE );
1238   indices.push_back( CameraActor::Property::LEFT_PLANE_DISTANCE );
1239   indices.push_back( CameraActor::Property::RIGHT_PLANE_DISTANCE );
1240   indices.push_back( CameraActor::Property::TOP_PLANE_DISTANCE );
1241   indices.push_back( CameraActor::Property::BOTTOM_PLANE_DISTANCE );
1242   indices.push_back( CameraActor::Property::TARGET_POSITION );
1243   indices.push_back( CameraActor::Property::PROJECTION_MATRIX );
1244   indices.push_back( CameraActor::Property::VIEW_MATRIX );
1245   indices.push_back( CameraActor::Property::INVERT_Y_AXIS );
1246
1247   DALI_TEST_CHECK( actor.GetPropertyCount() == ( Actor::New().GetPropertyCount() + indices.size() ) );
1248
1249   for( std::vector<Property::Index>::iterator iter = indices.begin(); iter != indices.end(); ++iter )
1250   {
1251     DALI_TEST_EQUALS( *iter, actor.GetPropertyIndex( actor.GetPropertyName( *iter ) ), TEST_LOCATION);
1252     DALI_TEST_CHECK( !actor.IsPropertyAnimatable( *iter ) );
1253
1254     if ( ( *iter == CameraActor::Property::PROJECTION_MATRIX ) ||
1255          ( *iter == CameraActor::Property::VIEW_MATRIX ) )
1256     {
1257       DALI_TEST_CHECK( !actor.IsPropertyWritable( *iter ) );
1258     }
1259     else
1260     {
1261       DALI_TEST_CHECK( actor.IsPropertyWritable( *iter ) );
1262     }
1263
1264     DALI_TEST_CHECK( actor.GetPropertyType( *iter ) == actor.GetPropertyType( *iter ) ); // just checking call succeeds
1265   }
1266
1267   // Set/Get one of them.
1268   const float newAspect = TEST_ASPECT_RATIO * 2.0f;
1269
1270   actor.SetProperty( CameraActor::Property::ASPECT_RATIO, Property::Value( newAspect ) );
1271   application.Render();
1272   application.SendNotification();
1273   application.Render();
1274   application.SendNotification();
1275
1276   DALI_TEST_EQUALS( actor.GetAspectRatio(), newAspect, TEST_LOCATION );
1277   END_TEST;
1278 }
1279
1280 template< typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
1281 void TEST_CAMERA_PROPERTY( P1 camera, P2 stringName, P3 type, P4 isWriteable, P5 isAnimateable, P6 isConstraintInput, P7 enumName, P8 LOCATION )
1282 {
1283   DALI_TEST_EQUALS( camera.GetPropertyName( enumName ), stringName, LOCATION );
1284   DALI_TEST_EQUALS( camera.GetPropertyIndex( stringName ), static_cast<Property::Index>(enumName), LOCATION );
1285   DALI_TEST_EQUALS( camera.GetPropertyType( enumName ), type, LOCATION );
1286   DALI_TEST_EQUALS( camera.IsPropertyWritable( enumName ), isWriteable, LOCATION );
1287   DALI_TEST_EQUALS( camera.IsPropertyAnimatable( enumName ), isAnimateable, LOCATION );
1288   DALI_TEST_EQUALS( camera.IsPropertyAConstraintInput( enumName ), isConstraintInput, LOCATION );
1289 }
1290 int UtcDaliCameraActorDefaultPropertiesInherited(void)
1291 {
1292   TestApplication application;
1293
1294   CameraActor actor = CameraActor::New();
1295   Stage stage = Stage::GetCurrent();
1296   stage.Add(actor);
1297   stage.GetRenderTaskList().GetTask(0).SetCameraActor( actor );
1298
1299   Stage::GetCurrent().Add( actor );
1300   application.Render( 0 );
1301   application.SendNotification();
1302
1303   const PropertyDetails CAMERA_DEFAULT_PROPERTY[] =
1304   {
1305 // actor
1306     { "parentOrigin",           Property::VECTOR3,  true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN },
1307     { "parentOriginX",          Property::FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_X },
1308     { "parentOriginY",          Property::FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_Y },
1309     { "parentOriginZ",          Property::FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_Z },
1310     { "anchorPoint",            Property::VECTOR3,  true,  false, true,  Dali::Actor::Property::ANCHOR_POINT },
1311     { "anchorPointX",           Property::FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_X },
1312     { "anchorPointY",           Property::FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_Y },
1313     { "anchorPointZ",           Property::FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_Z },
1314     { "size",                   Property::VECTOR3,  true,  true,  true,  Dali::Actor::Property::SIZE },
1315     { "sizeWidth",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_WIDTH },
1316     { "sizeHeight",             Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_HEIGHT },
1317     { "sizeDepth",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_DEPTH },
1318     { "position",               Property::VECTOR3,  true,  true,  true,  Dali::Actor::Property::POSITION },
1319     { "positionX",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_X },
1320     { "positionY",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_Y },
1321     { "positionZ",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_Z },
1322     { "worldPosition",          Property::VECTOR3,  false, false, true,  Dali::Actor::Property::WORLD_POSITION },
1323     { "worldPositionX",         Property::FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_X },
1324     { "worldPositionY",         Property::FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_Y },
1325     { "worldPositionZ",         Property::FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_Z },
1326     { "orientation",            Property::ROTATION, true,  true,  true,  Dali::Actor::Property::ORIENTATION },
1327     { "worldOrientation",       Property::ROTATION, false, false, true,  Dali::Actor::Property::WORLD_ORIENTATION },
1328     { "scale",                  Property::VECTOR3,  true,  true,  true,  Dali::Actor::Property::SCALE },
1329     { "scaleX",                 Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_X },
1330     { "scaleY",                 Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_Y },
1331     { "scaleZ",                 Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_Z },
1332     { "worldScale",             Property::VECTOR3,  false, false, true,  Dali::Actor::Property::WORLD_SCALE },
1333     { "visible",                Property::BOOLEAN,  true,  true,  true,  Dali::Actor::Property::VISIBLE },
1334     { "color",                  Property::VECTOR4,  true,  true,  true,  Dali::Actor::Property::COLOR },
1335     { "colorRed",               Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_RED },
1336     { "colorGreen",             Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_GREEN },
1337     { "colorBlue",              Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_BLUE },
1338     { "colorAlpha",             Property::FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_ALPHA },
1339     { "worldColor",             Property::VECTOR4,  false, false, true,  Dali::Actor::Property::WORLD_COLOR },
1340     { "worldMatrix",            Property::MATRIX,   false, false, true,  Dali::Actor::Property::WORLD_MATRIX },
1341     { "name",                   Property::STRING,   true,  false, false, Dali::Actor::Property::NAME },
1342     { "sensitive",              Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::SENSITIVE },
1343     { "leaveRequired",          Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::LEAVE_REQUIRED },
1344     { "inheritOrientation",     Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_ORIENTATION },
1345     { "inheritScale",           Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_SCALE },
1346     { "colorMode",              Property::STRING,   true,  false, false, Dali::Actor::Property::COLOR_MODE },
1347     { "drawMode",               Property::STRING,   true,  false, false, Dali::Actor::Property::DRAW_MODE },
1348     { "sizeModeFactor",         Property::VECTOR3,  true,  false, false, Dali::Actor::Property::SIZE_MODE_FACTOR },
1349     { "widthResizePolicy",      Property::STRING,   true,  false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY },
1350     { "heightResizePolicy",     Property::STRING,   true,  false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY },
1351     { "sizeScalePolicy",        Property::STRING,   true,  false, false, Dali::Actor::Property::SIZE_SCALE_POLICY },
1352     { "widthForHeight",         Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT },
1353     { "heightForWidth",         Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH },
1354     { "padding",                Property::VECTOR4,  true,  false, false, Dali::Actor::Property::PADDING },
1355     { "minimumSize",            Property::VECTOR2,  true,  false, false, Dali::Actor::Property::MINIMUM_SIZE },
1356     { "maximumSize",            Property::VECTOR2,  true,  false, false, Dali::Actor::Property::MAXIMUM_SIZE },
1357     { "inheritPosition",        Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_POSITION },
1358     { "clippingMode",           Property::STRING,   true,  false, false, Dali::Actor::Property::CLIPPING_MODE },
1359     { "layoutDirection",        Property::STRING,   true,  false, false, Dali::Actor::Property::LAYOUT_DIRECTION },
1360     { "inheritLayoutDirection", Property::BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION },
1361     { "siblingOrder",           Property::INTEGER,  true,  false, false, Dali::DevelActor::Property::SIBLING_ORDER },
1362     { "opacity",                Property::FLOAT,    true,  true,  true,  Dali::DevelActor::Property::OPACITY },
1363     { "screenPosition",         Property::VECTOR2,  false, false, false, Dali::DevelActor::Property::SCREEN_POSITION },
1364     { "positionUsesAnchorPoint",Property::BOOLEAN,  true,  false, false, Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT },
1365     { "culled",                 Property::BOOLEAN,  false, false, true,  Dali::DevelActor::Property::CULLED },
1366 // camera own
1367     { "type",                   Property::STRING,   true,    false,   true,   Dali::CameraActor::Property::TYPE                  },
1368     { "projectionMode",         Property::STRING,   true,    false,   true,   Dali::CameraActor::Property::PROJECTION_MODE       },
1369     { "fieldOfView",            Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::FIELD_OF_VIEW         },
1370     { "aspectRatio",            Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::ASPECT_RATIO          },
1371     { "nearPlaneDistance",      Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::NEAR_PLANE_DISTANCE   },
1372     { "farPlaneDistance",       Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::FAR_PLANE_DISTANCE    },
1373     { "leftPlaneDistance",      Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::LEFT_PLANE_DISTANCE   },
1374     { "rightPlaneDistance",     Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE  },
1375     { "topPlaneDistance",       Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::TOP_PLANE_DISTANCE    },
1376     { "bottomPlaneDistance",    Property::FLOAT,    true,    false,   true,   Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE },
1377     { "targetPosition",         Property::VECTOR3,  true,    false,   true,   Dali::CameraActor::Property::TARGET_POSITION       },
1378     { "projectionMatrix",       Property::MATRIX,   false,   false,   true,   Dali::CameraActor::Property::PROJECTION_MATRIX     },
1379     { "viewMatrix",             Property::MATRIX,   false,   false,   true,   Dali::CameraActor::Property::VIEW_MATRIX           },
1380     { "invertYAxis",            Property::BOOLEAN,  true,    false,   true,   Dali::CameraActor::Property::INVERT_Y_AXIS         }
1381   };
1382
1383   for( uint32_t index = 0; index < (sizeof(CAMERA_DEFAULT_PROPERTY)/sizeof(PropertyDetails)); ++index )
1384   {
1385     TEST_CAMERA_PROPERTY( actor,
1386                           CAMERA_DEFAULT_PROPERTY[ index ].name,
1387                           CAMERA_DEFAULT_PROPERTY[ index ].type,
1388                           CAMERA_DEFAULT_PROPERTY[ index ].writable,
1389                           CAMERA_DEFAULT_PROPERTY[ index ].animatable,
1390                           CAMERA_DEFAULT_PROPERTY[ index ].constraintInput,
1391                           CAMERA_DEFAULT_PROPERTY[ index ].enumIndex,
1392                           TEST_LOCATION );
1393   }
1394   END_TEST;
1395 }
1396
1397 int UtcDaliCameraActorModelView(void)
1398 {
1399   TestApplication application;
1400   tet_infoline( "Testing Dali::CameraActor Test view application" );
1401
1402   BufferImage image = CreateBufferImage();
1403
1404   Actor actor = CreateRenderableActor(image);
1405   actor.SetSize( 100.0f, 100.0f );
1406   actor.SetPosition( 20.0f, 30.0f, 40.0f );
1407   actor.SetParentOrigin( ParentOrigin::CENTER );
1408   Stage::GetCurrent().Add( actor );
1409
1410   application.SendNotification();
1411   application.Render( 0 );
1412   application.Render();
1413   application.SendNotification();
1414
1415   Matrix resultMatrix( true );
1416   resultMatrix.SetTransformComponents( Vector3::ONE, Quaternion::IDENTITY, actor.GetCurrentPosition() );
1417
1418   RenderTask task = Stage::GetCurrent().GetRenderTaskList().GetTask( 0 );
1419   CameraActor cameraActor = task.GetCameraActor();
1420
1421   Matrix viewMatrix( false );
1422   cameraActor.GetProperty( CameraActor::Property::VIEW_MATRIX ).Get( viewMatrix );
1423   Matrix::Multiply( resultMatrix, resultMatrix, viewMatrix );
1424
1425   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( "uModelView", resultMatrix ) );
1426   END_TEST;
1427 }
1428
1429 int UtcDaliCameraActorReadProjectionMatrix(void)
1430 {
1431   TestApplication application;
1432   tet_infoline( "Testing Dali::CameraActor::ReadProjectionMatrix()" );
1433
1434   CameraActor camera = Stage::GetCurrent().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
1435   application.SendNotification();
1436   application.Render( 0 );
1437   application.Render();
1438   application.SendNotification();
1439   Image image = CreateBufferImage();
1440   Actor actor = CreateRenderableActor( image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE );
1441   actor.SetSize( 100.0f, 100.0f );
1442   Stage::GetCurrent().Add( actor );
1443
1444   Matrix projectionMatrix;
1445   Matrix viewMatrix;
1446
1447   camera.GetProperty( CameraActor::CameraActor::Property::PROJECTION_MATRIX ).Get( projectionMatrix );
1448   camera.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( viewMatrix );
1449
1450   actor.RegisterProperty( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
1451   actor.RegisterProperty( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
1452
1453   Property::Index projectionMatrixPropertyIndex = actor.GetPropertyIndex( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME );
1454   Property::Index viewMatrixPropertyIndex = actor.GetPropertyIndex( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME );
1455
1456   Constraint projectionMatrixConstraint = Constraint::New<Dali::Matrix>( actor, projectionMatrixPropertyIndex, EqualToConstraint() );
1457   projectionMatrixConstraint.AddSource( Source( camera, CameraActor::Property::PROJECTION_MATRIX ) );
1458   Constraint viewMatrixConstraint = Constraint::New<Dali::Matrix>( actor, viewMatrixPropertyIndex, EqualToConstraint() );
1459   viewMatrixConstraint.AddSource( Source( camera, CameraActor::Property::VIEW_MATRIX ) );
1460
1461   projectionMatrixConstraint.Apply();
1462   viewMatrixConstraint.Apply();
1463
1464   application.SendNotification();
1465   application.Render();
1466
1467   // Test effects of Constraint.
1468   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME.c_str(), projectionMatrix) );
1469
1470   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME.c_str(), viewMatrix ) );
1471   END_TEST;
1472 }
1473
1474 int UtcDaliCameraActorAnimatedProperties(void)
1475 {
1476   TestApplication application;
1477   tet_infoline( "Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()" );
1478
1479   CameraActor camera = Stage::GetCurrent().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
1480   Actor actor = Actor::New();
1481   actor.SetSize( 100.0f, 100.0f );
1482   Stage::GetCurrent().Add( actor );
1483
1484   Constraint constraint = Constraint::New<Dali::Vector3>( actor, Actor::Property::POSITION, EqualToConstraint() );
1485   constraint.AddSource( Source( camera, Actor::Property::POSITION ) );
1486   constraint.Apply();
1487
1488   camera.SetPosition( 100.0f, 200.0f, 300.0f );
1489   application.SendNotification();
1490   application.Render();
1491
1492   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3( 100.0f, 200.0f, 300.0f ), TEST_LOCATION);
1493   END_TEST;
1494 }
1495
1496 int UtcDaliCameraActorPropertyIndices(void)
1497 {
1498   TestApplication application;
1499   CameraActor camera = Stage::GetCurrent().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
1500
1501   Actor basicActor = Actor::New();
1502   Property::IndexContainer indices;
1503   camera.GetPropertyIndices( indices );
1504   DALI_TEST_CHECK( indices.Size() > basicActor.GetPropertyCount() );
1505   DALI_TEST_EQUALS( indices.Size(), camera.GetPropertyCount(), TEST_LOCATION );
1506   END_TEST;
1507 }
1508
1509 int UtcDaliCameraActorCheckLookAtAndFreeLookViews01(void)
1510 {
1511   TestApplication application;
1512   Stage stage = Stage::GetCurrent();
1513   Vector2 stageSize = stage.GetSize();
1514
1515   CameraActor freeLookCameraActor = CameraActor::New( stageSize );
1516   freeLookCameraActor.SetParentOrigin( ParentOrigin::CENTER );
1517   freeLookCameraActor.SetType( Camera::FREE_LOOK );
1518
1519   Vector3 targetPosition( 30.0f, 240.0f, -256.0f );
1520   Actor target = Actor::New();
1521   target.SetParentOrigin( ParentOrigin::CENTER );
1522   target.SetPosition( targetPosition );
1523
1524   Constraint cameraOrientationConstraint = Constraint::New<Quaternion> ( freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt );
1525   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_POSITION ) );
1526   cameraOrientationConstraint.AddSource( Source( freeLookCameraActor,  Actor::Property::WORLD_POSITION ) );
1527   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_ORIENTATION ) );
1528   cameraOrientationConstraint.Apply();
1529
1530   CameraActor lookAtCameraActor = CameraActor::New( stageSize );
1531   lookAtCameraActor.SetType( Camera::LOOK_AT_TARGET );
1532   lookAtCameraActor.SetTargetPosition( targetPosition );
1533   lookAtCameraActor.SetParentOrigin( ParentOrigin::CENTER );
1534
1535   stage.Add( target );
1536   stage.Add( freeLookCameraActor );
1537   stage.Add( lookAtCameraActor );
1538
1539   // Create an arbitrary vector
1540   for( float x=-1.0f; x<=1.0f; x+=0.1f )
1541   {
1542     for( float y=-1.0f; y<1.0f; y+=0.1f )
1543     {
1544       for( float z=-1.0f; z<1.0f; z+=0.1f )
1545       {
1546         Vector3 position( x, y, z );
1547         position.Normalize();
1548         position *= 200.0f;
1549
1550         freeLookCameraActor.SetPosition( position );
1551         lookAtCameraActor.SetPosition( position );
1552
1553         application.SendNotification();
1554         application.Render();
1555         application.SendNotification();
1556         application.Render();
1557         Matrix freeLookViewMatrix;
1558         Matrix lookAtViewMatrix;
1559         freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
1560         lookAtCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( lookAtViewMatrix );
1561
1562         DALI_TEST_EQUALS( freeLookViewMatrix, lookAtViewMatrix, 0.01, TEST_LOCATION );
1563       }
1564     }
1565   }
1566   END_TEST;
1567 }
1568
1569 int UtcDaliCameraActorCheckLookAtAndFreeLookViews02(void)
1570 {
1571   TestApplication application;
1572   Stage stage = Stage::GetCurrent();
1573   Vector2 stageSize = stage.GetSize();
1574
1575   CameraActor freeLookCameraActor = CameraActor::New( stageSize );
1576   freeLookCameraActor.SetParentOrigin( ParentOrigin::CENTER );
1577   freeLookCameraActor.SetType( Camera::FREE_LOOK );
1578
1579   Vector3 targetPosition( 30.0f, 240.0f, -256.0f );
1580   Actor target = Actor::New();
1581   target.SetParentOrigin( ParentOrigin::CENTER );
1582   target.SetPosition( targetPosition );
1583
1584   Constraint cameraOrientationConstraint = Constraint::New<Quaternion> ( freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt );
1585   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_POSITION ) );
1586   cameraOrientationConstraint.AddSource( Source( freeLookCameraActor,  Actor::Property::WORLD_POSITION ) );
1587   cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_ORIENTATION ) );
1588   cameraOrientationConstraint.Apply();
1589
1590   CameraActor lookAtCameraActor = CameraActor::New( stageSize );
1591   lookAtCameraActor.SetType( Camera::LOOK_AT_TARGET );
1592   lookAtCameraActor.SetTargetPosition( targetPosition );
1593   lookAtCameraActor.SetParentOrigin( ParentOrigin::CENTER );
1594
1595   stage.Add( target );
1596   stage.Add( freeLookCameraActor );
1597   stage.Add( lookAtCameraActor );
1598   stage.GetRenderTaskList().GetTask(0).SetCameraActor( freeLookCameraActor );
1599
1600   // Create an arbitrary vector
1601   for( float x=-1.0f; x<=1.0f; x+=0.1f )
1602   {
1603     for( float y=-1.0f; y<1.0f; y+=0.1f )
1604     {
1605       for( float z=-1.0f; z<1.0f; z+=0.1f )
1606       {
1607         Vector3 position( x, y, z );
1608         position.Normalize();
1609         position *= 200.0f;
1610
1611         freeLookCameraActor.SetPosition( position );
1612         lookAtCameraActor.SetPosition( position );
1613
1614         application.SendNotification();
1615         application.Render();
1616         application.SendNotification();
1617         application.Render();
1618         Matrix freeLookViewMatrix;
1619         freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
1620
1621         Matrix freeLookWorld = freeLookCameraActor.GetCurrentWorldMatrix();
1622
1623         Matrix freeLookTest( false );
1624         Matrix::Multiply( freeLookTest, freeLookViewMatrix, freeLookWorld );
1625         DALI_TEST_EQUALS( freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION );
1626       }
1627     }
1628   }
1629
1630   END_TEST;
1631 }
1632
1633 int UtcDaliCameraActorCheckLookAtAndFreeLookViews03(void)
1634 {
1635   TestApplication application;
1636   Stage stage = Stage::GetCurrent();
1637   Vector2 stageSize = stage.GetSize();
1638
1639   Vector3 targetPosition( Vector3::ZERO );
1640   Vector3 cameraOffset( 0.0f, 0.0f, 100.0f );
1641
1642   CameraActor freeLookCameraActor = CameraActor::New( stageSize );
1643   freeLookCameraActor.SetType( Camera::FREE_LOOK );
1644   freeLookCameraActor.SetParentOrigin( ParentOrigin::CENTER );
1645
1646   Quaternion cameraOrientation( Radian( Degree( 180.0f ) ), Vector3::YAXIS );
1647   freeLookCameraActor.SetPosition( cameraOffset );
1648   freeLookCameraActor.SetOrientation( cameraOrientation );
1649
1650   Actor cameraAnchor = Actor::New();
1651   cameraAnchor.Add( freeLookCameraActor );
1652   stage.Add( cameraAnchor );
1653   stage.GetRenderTaskList().GetTask(0).SetCameraActor( freeLookCameraActor );
1654
1655   for( float angle = 1.0f; angle <= 180.0f; angle += 1.0f )
1656   {
1657     Quaternion rotation( Radian( Degree( angle ) ), Vector3::YAXIS );
1658
1659     freeLookCameraActor.SetPosition( rotation.Rotate( cameraOffset ) );
1660     cameraAnchor.SetOrientation( rotation );
1661
1662     application.SendNotification();
1663     application.Render();
1664     application.SendNotification();
1665     application.Render();
1666
1667     Matrix freeLookViewMatrix;
1668     freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
1669
1670     Matrix freeLookWorld = freeLookCameraActor.GetCurrentWorldMatrix();
1671
1672     Matrix freeLookTest( false );
1673     Matrix::Multiply( freeLookTest,  freeLookViewMatrix,  freeLookWorld );
1674     DALI_TEST_EQUALS( freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION );
1675   }
1676   END_TEST;
1677 }