dali-csharp-binder/dali-core/rotation-wrap.cpp

   1 /*
   2  * Copyright (c) 2023 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 // EXTERNAL INCLUDES
  19 #include <dali/public-api/math/quaternion.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali-csharp-binder/common/common.h>
  23
  24 #ifdef __cplusplus
  25 extern "C" {
  26 #endif
  27
  28 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_0()
  29 {
  30   void*             jresult;
  31   Dali::Quaternion* result = 0;
  32
  33   {
  34     try
  35     {
  36       result = (Dali::Quaternion*)new Dali::Quaternion();
  37     }
  38     CALL_CATCH_EXCEPTION(0);
  39   }
  40
  41   jresult = (void*)result;
  42   return jresult;
  43 }
  44
  45 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_1(void* nuiRadianAngle, void* nuiVector3)
  46 {
  47   void*             jresult;
  48   Dali::Radian*     radian = (Dali::Radian*)nuiRadianAngle;
  49   Dali::Vector3*    vector = (Dali::Vector3*)nuiVector3;
  50   Dali::Quaternion* result = 0;
  51
  52   if(!radian)
  53   {
  54     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
  55     return 0;
  56   }
  57   if(!vector)
  58   {
  59     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
  60     return 0;
  61   }
  62   {
  63     try
  64     {
  65       result = (Dali::Quaternion*)new Dali::Quaternion(*radian, (Dali::Vector3 const&)*vector);
  66     }
  67     CALL_CATCH_EXCEPTION(0);
  68   }
  69
  70   jresult = (void*)result;
  71   return jresult;
  72 }
  73
  74 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_2(void* nuiV0, void* nuiV1)
  75 {
  76   void*             jresult;
  77   Dali::Vector3*    v0     = (Dali::Vector3*)nuiV0;
  78   Dali::Vector3*    v1     = (Dali::Vector3*)nuiV1;
  79   Dali::Quaternion* result = 0;
  80
  81   if(!v0)
  82   {
  83     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
  84     return 0;
  85   }
  86   if(!v1)
  87   {
  88     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
  89     return 0;
  90   }
  91   {
  92     try
  93     {
  94       result = (Dali::Quaternion*)new Dali::Quaternion((Dali::Vector3 const&)*v0, (Dali::Vector3 const&)*v1);
  95     }
  96     CALL_CATCH_EXCEPTION(0);
  97   }
  98
  99   jresult = (void*)result;
 100   return jresult;
 101 }
 102
 103 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_3(void* nuiPitchRadian, void* nuiYawRadian, void* nuiRollRadian)
 104 {
 105   void*             jresult;
 106   Dali::Radian*     pitch  = (Dali::Radian*)nuiPitchRadian;
 107   Dali::Radian*     yaw    = (Dali::Radian*)nuiYawRadian;
 108   Dali::Radian*     roll   = (Dali::Radian*)nuiRollRadian;
 109   Dali::Quaternion* result = 0;
 110
 111   if(!pitch)
 112   {
 113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type pitch is null", 0);
 114     return 0;
 115   }
 116   if(!yaw)
 117   {
 118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type yaw is null", 0);
 119     return 0;
 120   }
 121   if(!roll)
 122   {
 123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type roll is null", 0);
 124     return 0;
 125   }
 126   {
 127     try
 128     {
 129       result = (Dali::Quaternion*)new Dali::Quaternion((Dali::Radian const&)*pitch, (Dali::Radian const&)*yaw, (Dali::Radian const&)*roll);
 130     }
 131     CALL_CATCH_EXCEPTION(0);
 132   }
 133
 134   jresult = (void*)result;
 135   return jresult;
 136 }
 137
 138 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_4(void* nuiVector4)
 139 {
 140   void*             jresult;
 141   Dali::Vector4*    vector4    = (Dali::Vector4*)nuiVector4;
 142   Dali::Quaternion* result = 0;
 143
 144   if(!vector4)
 145   {
 146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type vector4 is null", 0);
 147     return 0;
 148   }
 149   {
 150     try
 151     {
 152       result = (Dali::Quaternion*)new Dali::Quaternion((Dali::Vector4 const&)*vector4);
 153     }
 154     CALL_CATCH_EXCEPTION(0);
 155   }
 156
 157   jresult = (void*)result;
 158   return jresult;
 159 }
 160
 161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void* nuiRotation)
 162 {
 163   Dali::Quaternion* quaternion = (Dali::Quaternion*)0;
 164
 165   quaternion = (Dali::Quaternion*)nuiRotation;
 166   {
 167     try
 168     {
 169       delete quaternion;
 170     }
 171     CALL_CATCH_EXCEPTION();
 172   }
 173 }
 174
 175 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get()
 176 {
 177   void*             jresult;
 178   Dali::Quaternion* result = 0;
 179
 180   result  = (Dali::Quaternion*)&Dali::Quaternion::IDENTITY;
 181   jresult = (void*)result;
 182   return jresult;
 183 }
 184
 185 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void* nuiRotation)
 186 {
 187   bool              result;
 188   Dali::Quaternion* quaternion = (Dali::Quaternion*)0;
 189
 190   quaternion = (Dali::Quaternion*)nuiRotation;
 191   {
 192     try
 193     {
 194       result = (bool)((Dali::Quaternion const*)quaternion)->IsIdentity();
 195     }
 196     CALL_CATCH_EXCEPTION(0);
 197   }
 198
 199   return result;
 200 }
 201
 202 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void* nuiRotation, void* nuiAxis, void* nuiRadianAngle)
 203 {
 204   bool              result;
 205   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 206   Dali::Vector3*    axis       = (Dali::Vector3*)nuiAxis;
 207   Dali::Radian*     radian     = (Dali::Radian*)nuiRadianAngle;
 208
 209   if(!axis)
 210   {
 211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
 212     return 0;
 213   }
 214   if(!radian)
 215   {
 216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
 217     return 0;
 218   }
 219   {
 220     try
 221     {
 222       result = (bool)((Dali::Quaternion const*)quaternion)->ToAxisAngle(*axis, *radian);
 223     }
 224     CALL_CATCH_EXCEPTION(0);
 225   }
 226
 227   return result;
 228 }
 229
 230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_SetEulerAngle(void* nuiRotation, void* nuiPitchRadian, void* nuiYawRadian, void* nuiRollRadian)
 231 {
 232   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 233   Dali::Radian*     pitch      = (Dali::Radian*)nuiPitchRadian;
 234   Dali::Radian*     yaw        = (Dali::Radian*)nuiYawRadian;
 235   Dali::Radian*     roll       = (Dali::Radian*)nuiRollRadian;
 236
 237   if(!pitch)
 238   {
 239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type pitch is null", 0);
 240     return;
 241   }
 242   if(!yaw)
 243   {
 244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type yaw is null", 0);
 245     return;
 246   }
 247   if(!roll)
 248   {
 249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type roll is null", 0);
 250     return;
 251   }
 252   {
 253     try
 254     {
 255       ((Dali::Quaternion*)quaternion)->SetEuler((Dali::Radian const&)*pitch, (Dali::Radian const&)*yaw, (Dali::Radian const&)*roll);
 256     }
 257     CALL_CATCH_EXCEPTION();
 258   }
 259 }
 260
 261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_GetEulerAngle(void* nuiRotation, void* nuiPitchRadian, void* nuiYawRadian, void* nuiRollRadian)
 262 {
 263   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 264   Dali::Radian*     pitch      = (Dali::Radian*)nuiPitchRadian;
 265   Dali::Radian*     yaw        = (Dali::Radian*)nuiYawRadian;
 266   Dali::Radian*     roll       = (Dali::Radian*)nuiRollRadian;
 267
 268   if(!pitch)
 269   {
 270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type pitch is null", 0);
 271     return;
 272   }
 273   if(!yaw)
 274   {
 275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type yaw is null", 0);
 276     return;
 277   }
 278   if(!roll)
 279   {
 280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type roll is null", 0);
 281     return;
 282   }
 283   {
 284     try
 285     {
 286       Dali::Vector4 result = (Dali::Vector4)((Dali::Quaternion const*)quaternion)->EulerAngles();
 287       // Convert from EulerAngles to pitch / yaw / roll
 288       *pitch = Dali::Radian(result.x);
 289       *yaw   = Dali::Radian(result.y);
 290       *roll  = Dali::Radian(result.z);
 291     }
 292     CALL_CATCH_EXCEPTION();
 293   }
 294 }
 295
 296 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Add(void* nuiRotation0, void* nuiRotation1)
 297 {
 298   void*             jresult;
 299   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 300   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 301   Dali::Quaternion  result;
 302
 303   if(!quaternion1)
 304   {
 305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 306     return 0;
 307   }
 308   {
 309     try
 310     {
 311       result = ((Dali::Quaternion const*)quaternion0)->operator+((Dali::Quaternion const&)*quaternion1);
 312     }
 313     CALL_CATCH_EXCEPTION(0);
 314   }
 315
 316   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 317   return jresult;
 318 }
 319
 320 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Subtract_0(void* nuiRotation0, void* nuiRotation1)
 321 {
 322   void*             jresult;
 323   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 324   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 325   Dali::Quaternion  result;
 326
 327   if(!quaternion1)
 328   {
 329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 330     return 0;
 331   }
 332   {
 333     try
 334     {
 335       result = ((Dali::Quaternion const*)quaternion0)->operator-((Dali::Quaternion const&)*quaternion1);
 336     }
 337     CALL_CATCH_EXCEPTION(0);
 338   }
 339
 340   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 341   return jresult;
 342 }
 343
 344 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Multiply_0(void* nuiRotation0, void* nuiRotation1)
 345 {
 346   void*             jresult;
 347   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 348   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 349   Dali::Quaternion  result;
 350
 351   if(!quaternion1)
 352   {
 353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 354     return 0;
 355   }
 356   {
 357     try
 358     {
 359       result = ((Dali::Quaternion const*)quaternion0)->operator*((Dali::Quaternion const&)*quaternion1);
 360     }
 361     CALL_CATCH_EXCEPTION(0);
 362   }
 363
 364   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 365   return jresult;
 366 }
 367
 368 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Multiply_1(void* nuiRotation, void* nuiVector3)
 369 {
 370   void*             jresult;
 371   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 372   Dali::Vector3*    vector     = (Dali::Vector3*)nuiVector3;
 373   Dali::Vector3     result;
 374
 375   if(!vector)
 376   {
 377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 378     return 0;
 379   }
 380   {
 381     try
 382     {
 383       result = ((Dali::Quaternion const*)quaternion)->operator*((Dali::Vector3 const&)*vector);
 384     }
 385     CALL_CATCH_EXCEPTION(0);
 386   }
 387
 388   jresult = new Dali::Vector3((const Dali::Vector3&)result);
 389   return jresult;
 390 }
 391
 392 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Divide_0(void* nuiRotation0, void* nuiRotation1)
 393 {
 394   void*             jresult;
 395   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 396   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 397   Dali::Quaternion  result;
 398
 399   if(!quaternion1)
 400   {
 401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 402     return 0;
 403   }
 404   {
 405     try
 406     {
 407       result = ((Dali::Quaternion const*)quaternion0)->operator/((Dali::Quaternion const&)*quaternion1);
 408     }
 409     CALL_CATCH_EXCEPTION(0);
 410   }
 411
 412   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 413   return jresult;
 414 }
 415
 416 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Multiply_2(void* nuiRotation, float scale)
 417 {
 418   void*             jresult;
 419   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 420   Dali::Quaternion  result;
 421   {
 422     try
 423     {
 424       result = ((Dali::Quaternion const*)quaternion)->operator*(scale);
 425     }
 426     CALL_CATCH_EXCEPTION(0);
 427   }
 428
 429   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 430   return jresult;
 431 }
 432
 433 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Divide_1(void* nuiRotation, float scale)
 434 {
 435   void*             jresult;
 436   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 437   Dali::Quaternion  result;
 438   {
 439     try
 440     {
 441       result = ((Dali::Quaternion const*)quaternion)->operator/(scale);
 442     }
 443     CALL_CATCH_EXCEPTION(0);
 444   }
 445
 446   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 447   return jresult;
 448 }
 449
 450 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Subtract_1(void* nuiRotation)
 451 {
 452   void*             jresult;
 453   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 454   Dali::Quaternion  result;
 455
 456   {
 457     try
 458     {
 459       result = ((Dali::Quaternion const*)quaternion)->operator-();
 460     }
 461     CALL_CATCH_EXCEPTION(0);
 462   }
 463
 464   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 465   return jresult;
 466 }
 467
 468 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void* nuiRotation0, void* nuiRotation1)
 469 {
 470   void*             jresult;
 471   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 472   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 473   Dali::Quaternion* result      = 0;
 474
 475   if(!quaternion1)
 476   {
 477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 478     return 0;
 479   }
 480   {
 481     try
 482     {
 483       result = (Dali::Quaternion*)&(quaternion0)->operator+=((Dali::Quaternion const&)*quaternion1);
 484     }
 485     CALL_CATCH_EXCEPTION(0);
 486   }
 487
 488   jresult = (void*)result;
 489   return jresult;
 490 }
 491
 492 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void* nuiRotation0, void* nuiRotation1)
 493 {
 494   void*             jresult;
 495   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 496   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 497   Dali::Quaternion* result      = 0;
 498
 499   if(!quaternion1)
 500   {
 501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 502     return 0;
 503   }
 504   {
 505     try
 506     {
 507       result = (Dali::Quaternion*)&(quaternion0)->operator-=((Dali::Quaternion const&)*quaternion1);
 508     }
 509     CALL_CATCH_EXCEPTION(0);
 510   }
 511
 512   jresult = (void*)result;
 513   return jresult;
 514 }
 515
 516 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign_0(void* nuiRotation0, void* nuiRotation1)
 517 {
 518   void*             jresult;
 519   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 520   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 521   Dali::Quaternion* result      = 0;
 522
 523   if(!quaternion1)
 524   {
 525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 526     return 0;
 527   }
 528   {
 529     try
 530     {
 531       result = (Dali::Quaternion*)&(quaternion0)->operator*=((Dali::Quaternion const&)*quaternion1);
 532     }
 533     CALL_CATCH_EXCEPTION(0);
 534   }
 535
 536   jresult = (void*)result;
 537   return jresult;
 538 }
 539
 540 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign_1(void* nuiRotation, float scale)
 541 {
 542   void*             jresult;
 543   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 544   Dali::Quaternion* result;
 545   {
 546     try
 547     {
 548       result = (Dali::Quaternion*)&(quaternion)->operator*=(scale);
 549     }
 550     CALL_CATCH_EXCEPTION(0);
 551   }
 552
 553   jresult = (void*)result;
 554   return jresult;
 555 }
 556
 557 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void* nuiRotation, float scale)
 558 {
 559   void*             jresult;
 560   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 561   Dali::Quaternion* result;
 562   {
 563     try
 564     {
 565       result = (Dali::Quaternion*)&(quaternion)->operator/=(scale);
 566     }
 567     CALL_CATCH_EXCEPTION(0);
 568   }
 569
 570   jresult = (void*)result;
 571   return jresult;
 572 }
 573
 574 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void* nuiRotation0, void* nuiRotation1)
 575 {
 576   bool              result;
 577   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 578   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 579
 580   if(!quaternion1)
 581   {
 582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 583     return 0;
 584   }
 585   {
 586     try
 587     {
 588       result = (bool)((Dali::Quaternion const*)quaternion0)->operator==((Dali::Quaternion const&)*quaternion1);
 589     }
 590     CALL_CATCH_EXCEPTION(0);
 591   }
 592
 593   return result;
 594 }
 595
 596 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void* nuiRotation0, void* nuiRotation1)
 597 {
 598   bool              result;
 599   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 600   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 601
 602   if(!quaternion1)
 603   {
 604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 605     return 0;
 606   }
 607   {
 608     try
 609     {
 610       result = (bool)((Dali::Quaternion const*)quaternion0)->operator!=((Dali::Quaternion const&)*quaternion1);
 611     }
 612     CALL_CATCH_EXCEPTION(0);
 613   }
 614
 615   return result;
 616 }
 617
 618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void* nuiRotation)
 619 {
 620   float             result;
 621   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 622
 623   {
 624     try
 625     {
 626       result = (float)((Dali::Quaternion const*)quaternion)->Length();
 627     }
 628     CALL_CATCH_EXCEPTION(0);
 629   }
 630
 631   return result;
 632 }
 633
 634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void* nuiRotation)
 635 {
 636   float             result;
 637   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 638
 639   {
 640     try
 641     {
 642       result = (float)((Dali::Quaternion const*)quaternion)->LengthSquared();
 643     }
 644     CALL_CATCH_EXCEPTION(0);
 645   }
 646
 647   return result;
 648 }
 649
 650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void* nuiRotation)
 651 {
 652   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 653
 654   {
 655     try
 656     {
 657       (quaternion)->Normalize();
 658     }
 659     CALL_CATCH_EXCEPTION();
 660   }
 661 }
 662
 663 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void* nuiRotation)
 664 {
 665   void*             jresult;
 666   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 667   Dali::Quaternion  result;
 668
 669   {
 670     try
 671     {
 672       result = ((Dali::Quaternion const*)quaternion)->Normalized();
 673     }
 674     CALL_CATCH_EXCEPTION(0);
 675   }
 676
 677   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 678   return jresult;
 679 }
 680
 681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void* nuiRotation)
 682 {
 683   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 684
 685   {
 686     try
 687     {
 688       (quaternion)->Conjugate();
 689     }
 690     CALL_CATCH_EXCEPTION();
 691   }
 692 }
 693
 694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void* nuiRotation)
 695 {
 696   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 697
 698   {
 699     try
 700     {
 701       (quaternion)->Invert();
 702     }
 703     CALL_CATCH_EXCEPTION();
 704   }
 705 }
 706
 707 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Log(void* nuiRotation)
 708 {
 709   void*             jresult;
 710   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 711   Dali::Quaternion  result;
 712
 713   {
 714     try
 715     {
 716       result = ((Dali::Quaternion const*)quaternion)->Log();
 717     }
 718     CALL_CATCH_EXCEPTION(0);
 719   }
 720
 721   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 722   return jresult;
 723 }
 724
 725 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Exp(void* nuiRotation)
 726 {
 727   void*             jresult;
 728   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 729   Dali::Quaternion  result;
 730
 731   {
 732     try
 733     {
 734       result = ((Dali::Quaternion const*)quaternion)->Exp();
 735     }
 736     CALL_CATCH_EXCEPTION(0);
 737   }
 738
 739   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 740   return jresult;
 741 }
 742
 743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void* nuiRotation0, void* nuiRotation1)
 744 {
 745   float             result;
 746   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 747   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 748
 749   if(!quaternion0)
 750   {
 751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 752     return 0;
 753   }
 754   if(!quaternion1)
 755   {
 756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 757     return 0;
 758   }
 759   {
 760     try
 761     {
 762       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1);
 763     }
 764     CALL_CATCH_EXCEPTION(0);
 765   }
 766
 767   return result;
 768 }
 769
 770 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void* nuiRotation0, void* nuiRotation1, float progress)
 771 {
 772   void*             jresult;
 773   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 774   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 775   Dali::Quaternion  result;
 776
 777   if(!quaternion0)
 778   {
 779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 780     return 0;
 781   }
 782   if(!quaternion1)
 783   {
 784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 785     return 0;
 786   }
 787
 788   {
 789     try
 790     {
 791       result = Dali::Quaternion::Lerp((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1, progress);
 792     }
 793     CALL_CATCH_EXCEPTION(0);
 794   }
 795
 796   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 797   return jresult;
 798 }
 799
 800 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void* nuiRotation0, void* nuiRotation1, float progress)
 801 {
 802   void*             jresult;
 803   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 804   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 805   Dali::Quaternion  result;
 806
 807   if(!quaternion0)
 808   {
 809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 810     return 0;
 811   }
 812   if(!quaternion1)
 813   {
 814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 815     return 0;
 816   }
 817
 818   {
 819     try
 820     {
 821       result = Dali::Quaternion::Slerp((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1, progress);
 822     }
 823     CALL_CATCH_EXCEPTION(0);
 824   }
 825
 826   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 827   return jresult;
 828 }
 829
 830 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void* nuiRotation0, void* nuiRotation1, float progress)
 831 {
 832   void*             jresult;
 833   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 834   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 835   Dali::Quaternion  result;
 836
 837   if(!quaternion0)
 838   {
 839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 840     return 0;
 841   }
 842   if(!quaternion1)
 843   {
 844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 845     return 0;
 846   }
 847
 848   {
 849     try
 850     {
 851       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1, progress);
 852     }
 853     CALL_CATCH_EXCEPTION(0);
 854   }
 855
 856   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 857   return jresult;
 858 }
 859
 860 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Squad(void* nuiStart, void* nuiEnd, void* nuiControl0, void* nuiControl1, float progress)
 861 {
 862   void*             jresult;
 863   Dali::Quaternion* start    = (Dali::Quaternion*)nuiStart;
 864   Dali::Quaternion* end      = (Dali::Quaternion*)nuiEnd;
 865   Dali::Quaternion* control0 = (Dali::Quaternion*)nuiControl0;
 866   Dali::Quaternion* control1 = (Dali::Quaternion*)nuiControl1;
 867   Dali::Quaternion  result;
 868
 869   if(!start)
 870   {
 871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 872     return 0;
 873   }
 874   if(!end)
 875   {
 876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 877     return 0;
 878   }
 879   if(!control0)
 880   {
 881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 882     return 0;
 883   }
 884   if(!control1)
 885   {
 886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 887     return 0;
 888   }
 889   {
 890     try
 891     {
 892       result = Dali::Quaternion::Squad((Dali::Quaternion const&)*start, (Dali::Quaternion const&)*end, (Dali::Quaternion const&)*control0, (Dali::Quaternion const&)*control1, progress);
 893     }
 894     CALL_CATCH_EXCEPTION(0);
 895   }
 896
 897   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
 898   return jresult;
 899 }
 900
 901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void* nuiRotation0, void* nuiRotation1)
 902 {
 903   float             result;
 904   Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0;
 905   Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1;
 906
 907   if(!quaternion0)
 908   {
 909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 910     return 0;
 911   }
 912   if(!quaternion1)
 913   {
 914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 915     return 0;
 916   }
 917   {
 918     try
 919     {
 920       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1);
 921     }
 922     CALL_CATCH_EXCEPTION(0);
 923   }
 924
 925   return result;
 926 }
 927
 928 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Rotate_Vector3(void* nuiRotation, void* nuiVector3)
 929 {
 930   void*             jresult;
 931   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 932   Dali::Vector3*    vector3    = (Dali::Vector3*)nuiVector3;
 933   Dali::Vector3     result;
 934
 935   if(!quaternion)
 936   {
 937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 938     return 0;
 939   }
 940   if(!vector3)
 941   {
 942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 943     return 0;
 944   }
 945   {
 946     try
 947     {
 948       result = ((Dali::Quaternion const*)quaternion)->Rotate(*vector3);
 949     }
 950     CALL_CATCH_EXCEPTION(0);
 951   }
 952
 953   jresult = new Dali::Vector3((const Dali::Vector3&)result);
 954   return jresult;
 955 }
 956
 957 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Rotate_Vector4(void* nuiRotation, void* nuiVector4)
 958 {
 959   void*             jresult;
 960   Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation;
 961   Dali::Vector4*    vector4    = (Dali::Vector4*)nuiVector4;
 962   Dali::Vector4     result;
 963
 964   if(!quaternion)
 965   {
 966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 967     return 0;
 968   }
 969   if(!vector4)
 970   {
 971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 972     return 0;
 973   }
 974   {
 975     try
 976     {
 977       result = ((Dali::Quaternion const*)quaternion)->Rotate(*vector4);
 978     }
 979     CALL_CATCH_EXCEPTION(0);
 980   }
 981
 982   jresult = new Dali::Vector4((const Dali::Vector4&)result);
 983   return jresult;
 984 }
 985
 986 #ifdef __cplusplus
 987 }
 988 #endif