dali-csharp-binder/dali-physics-3d/physics-adaptor-3d-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 #include <dali-physics/public-api/physics-adaptor.h>
  19 #include <dali-physics/public-api/physics-actor.h>
  20
  21 #include <dali-physics/integration-api/integ-physics-adaptor.h>
  22
  23 #include <btBulletDynamicsCommon.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali-csharp-binder/common/common.h>
  27
  28 #ifdef __cplusplus
  29 extern "C" {
  30 #endif
  31
  32   using Dali::Toolkit::Physics::PhysicsActor;
  33   using Dali::Toolkit::Physics::PhysicsAdaptor;
  34
  35   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_PhysicsAdaptor__SWIG_0()
  36   {
  37     void*        jresult;
  38     PhysicsAdaptor* result = 0;
  39
  40     {
  41       try
  42       {
  43         result = (PhysicsAdaptor*)new PhysicsAdaptor();
  44       }
  45       CALL_CATCH_EXCEPTION(0);
  46     }
  47
  48     jresult = (void*)result;
  49     return jresult;
  50   }
  51
  52   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_New(void* csMatrix, void* csSize)
  53   {
  54     void*       jresult;
  55     PhysicsAdaptor result;
  56
  57     Dali::Matrix *matrixPtr = (Dali::Matrix*)csMatrix;
  58     if(!matrixPtr)
  59     {
  60       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
  61       return 0;
  62     }
  63     Dali::Vector2 *sizePtr = (Dali::Vector2*)csSize;
  64     if(!sizePtr)
  65     {
  66       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Vector2 const & type is null", 0);
  67       return 0;
  68     }
  69
  70     {
  71       try
  72       {
  73         Dali::Uint16Pair size(uint16_t(sizePtr->x), uint16_t(sizePtr->y));
  74         // Stack allocate a handle
  75         result = PhysicsAdaptor::New(*matrixPtr, size);
  76       }
  77       CALL_CATCH_EXCEPTION(0);
  78     }
  79
  80     // Heap allocate a handle using copy constructor
  81     jresult = new PhysicsAdaptor((const PhysicsAdaptor&)result);
  82     return jresult;
  83   }
  84
  85   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_DownCast(void* csHandle)
  86   {
  87     Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle;
  88     PhysicsAdaptor result;
  89
  90     if(!handle)
  91     {
  92       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
  93       return 0;
  94     }
  95     {
  96       try
  97       {
  98         result = PhysicsAdaptor::DownCast(*handle);
  99       }
 100       CALL_CATCH_EXCEPTION(0);
 101     }
 102     return new PhysicsAdaptor((const PhysicsAdaptor&)result);
 103   }
 104
 105   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PhysicsAdaptor(void* csPhysicsAdaptor)
 106   {
 107     PhysicsAdaptor* physicsAdaptor = (PhysicsAdaptor*)csPhysicsAdaptor;
 108     {
 109       try
 110       {
 111         delete physicsAdaptor;
 112       }
 113       CALL_CATCH_EXCEPTION();
 114     }
 115   }
 116
 117   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_PhysicsAdaptor__SWIG_1(void* csPhysicsAdaptor)
 118   {
 119     PhysicsAdaptor* physicsAdaptor = (PhysicsAdaptor*)csPhysicsAdaptor;
 120     PhysicsAdaptor* result = 0;
 121
 122     if(!physicsAdaptor)
 123     {
 124       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 125       return 0;
 126     }
 127     {
 128       try
 129       {
 130         result = (PhysicsAdaptor*)new PhysicsAdaptor((PhysicsAdaptor const&)*physicsAdaptor);
 131       }
 132       CALL_CATCH_EXCEPTION(0);
 133     }
 134
 135     return (void*)result;
 136   }
 137
 138   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_Assign(void* csDest, void* csSrc)
 139   {
 140     PhysicsAdaptor* dest   = (PhysicsAdaptor*)csDest;
 141     PhysicsAdaptor* src    = (PhysicsAdaptor*)csSrc;
 142     PhysicsAdaptor* result = 0;
 143
 144     if(!src)
 145     {
 146       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 147       return 0;
 148     }
 149     {
 150       try
 151       {
 152         result = (PhysicsAdaptor*)&(dest)->operator=((PhysicsAdaptor const&)*src);
 153       }
 154       CALL_CATCH_EXCEPTION(0);
 155     }
 156
 157     return (void*)result;
 158   }
 159
 160
 161
 162 // Methods
 163   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_SetTimestep(void* csAdaptor, float timestep)
 164   {
 165     PhysicsAdaptor* adaptor   = (PhysicsAdaptor*)csAdaptor;
 166     if(!adaptor)
 167     {
 168       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 169       return;
 170     }
 171     {
 172       try
 173       {
 174         adaptor->SetTimestep(timestep);
 175       }
 176       CALL_CATCH_EXCEPTION();
 177     }
 178   }
 179
 180   SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_GetTimestep(void* csAdaptor)
 181   {
 182     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 183     float result{0.0f};
 184     if(!adaptor)
 185     {
 186       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 187       return result;
 188     }
 189
 190     {
 191       try
 192       {
 193         result = adaptor->GetTimestep();
 194       }
 195       CALL_CATCH_EXCEPTION(0.0f);
 196     }
 197     return result;
 198   }
 199
 200   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_CreateDebugLayer(void* csAdaptor, void* csWindow)
 201   {
 202     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 203     Dali::Layer result;
 204     if(!adaptor)
 205     {
 206       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 207       return 0;
 208     }
 209     Dali::Window* window = (Dali::Window*)csWindow;
 210     if(!window)
 211     {
 212       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
 213       return 0;
 214     }
 215     {
 216       try
 217       {
 218         result = adaptor->CreateDebugLayer(*window);
 219       }
 220       CALL_CATCH_EXCEPTION(0);
 221     }
 222     return new Dali::Layer((const Dali::Layer&)result);
 223   }
 224
 225   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_TranslateToPhysicsSpace_1(void* csAdaptor, Dali::Vector3* csPosition)
 226   {
 227     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 228     Dali::Vector3 result;
 229     if(!adaptor)
 230     {
 231       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 232       return 0;
 233     }
 234     if(!csPosition)
 235     {
 236       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 237       return 0;
 238     }
 239     {
 240       try
 241       {
 242         result = adaptor->TranslateToPhysicsSpace(*csPosition);
 243       }
 244       CALL_CATCH_EXCEPTION(0);
 245     }
 246     return new Dali::Vector3((const Dali::Vector3&)result);
 247   }
 248
 249   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_TranslateToPhysicsSpace_2(void* csAdaptor, Dali::Quaternion* csRotation)
 250   {
 251     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 252     Dali::Quaternion result;
 253     if(!adaptor)
 254     {
 255       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 256       return 0;
 257     }
 258     if(!csRotation)
 259     {
 260       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 261       return 0;
 262     }
 263     {
 264       try
 265       {
 266         result = adaptor->TranslateToPhysicsSpace(*csRotation);
 267       }
 268       CALL_CATCH_EXCEPTION(0);
 269     }
 270     return new Dali::Quaternion((const Dali::Quaternion&)result);
 271   }
 272
 273   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_TranslateFromPhysicsSpace_1(void* csAdaptor, Dali::Vector3* csPosition)
 274   {
 275     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 276     Dali::Vector3 result;
 277     if(!adaptor)
 278     {
 279       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 280       return 0;
 281     }
 282     if(!csPosition)
 283     {
 284       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 285       return 0;
 286     }
 287     {
 288       try
 289       {
 290         result = adaptor->TranslateFromPhysicsSpace(*csPosition);
 291       }
 292       CALL_CATCH_EXCEPTION(0);
 293     }
 294     return new Dali::Vector3((const Dali::Vector3&)result);
 295   }
 296
 297   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_TranslateFromPhysicsSpace_2(void* csAdaptor, Dali::Quaternion* csRotation)
 298   {
 299     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 300     Dali::Quaternion result;
 301     if(!adaptor)
 302     {
 303       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 304       return 0;
 305     }
 306     if(!csRotation)
 307     {
 308       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
 309       return 0;
 310     }
 311     {
 312       try
 313       {
 314         result = adaptor->TranslateFromPhysicsSpace(*csRotation);
 315       }
 316       CALL_CATCH_EXCEPTION(0);
 317     }
 318     return new Dali::Quaternion((const Dali::Quaternion&)result);
 319   }
 320
 321
 322   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_ConvertVectorToPhysicsSpace(void* csAdaptor, Dali::Vector3* csVector)
 323   {
 324     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 325     Dali::Vector3 result;
 326     if(!adaptor)
 327     {
 328       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 329       return 0;
 330     }
 331     if(!csVector)
 332     {
 333       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 334       return 0;
 335     }
 336     {
 337       try
 338       {
 339         result = adaptor->ConvertVectorToPhysicsSpace(*csVector);
 340       }
 341       CALL_CATCH_EXCEPTION(0);
 342     }
 343     return new Dali::Vector3((const Dali::Vector3&)result);
 344   }
 345
 346   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_ConvertVectorFromPhysicsSpace(void* csAdaptor, Dali::Vector3* csVector)
 347   {
 348     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 349     Dali::Vector3 result;
 350     if(!adaptor)
 351     {
 352       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 353       return 0;
 354     }
 355     if(!csVector)
 356     {
 357       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 358       return 0;
 359     }
 360     {
 361       try
 362       {
 363         result = adaptor->ConvertVectorFromPhysicsSpace(*csVector);
 364       }
 365       CALL_CATCH_EXCEPTION(0);
 366     }
 367     return new Dali::Vector3((const Dali::Vector3&)result);
 368   }
 369
 370
 371   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_SetTransformAndSize(void* csAdaptor, void* csTransform, void* csSize)
 372   {
 373     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 374     if(!adaptor)
 375     {
 376       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 377       return;
 378     }
 379     if(!csTransform)
 380     {
 381       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
 382       return;
 383     }
 384     Dali::Vector2 *sizePtr = (Dali::Vector2*)csSize;
 385     if(!sizePtr)
 386     {
 387       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Vector2 const & type is null", 0);
 388       return;
 389     }
 390
 391     {
 392       try
 393       {
 394         Dali::Uint16Pair size(uint16_t(sizePtr->x), uint16_t(sizePtr->y));
 395         adaptor->SetTransformAndSize((const Dali::Matrix&)(*(Dali::Matrix*)csTransform), size);
 396       }
 397       CALL_CATCH_EXCEPTION();
 398     }
 399   }
 400
 401   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_SetIntegrationState(void* csAdaptor, int csIntegrationState)
 402   {
 403     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 404     if(!adaptor)
 405     {
 406       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 407       return;
 408     }
 409     {
 410       try
 411       {
 412         adaptor->SetIntegrationState(PhysicsAdaptor::IntegrationState(csIntegrationState));
 413       }
 414       CALL_CATCH_EXCEPTION();
 415     }
 416   }
 417
 418   SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_GetIntegrationState(void* csAdaptor)
 419   {
 420     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 421     PhysicsAdaptor::IntegrationState result;
 422     if(!adaptor)
 423     {
 424       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 425       return 0;
 426     }
 427     {
 428       try
 429       {
 430         result = adaptor->GetIntegrationState();
 431       }
 432       CALL_CATCH_EXCEPTION(0);
 433     }
 434     return(int)result;
 435   }
 436
 437
 438   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_SetDebugState(void* csAdaptor, int csDebugState)
 439   {
 440     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 441     if(!adaptor)
 442     {
 443       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 444       return;
 445     }
 446     {
 447       try
 448       {
 449         adaptor->SetDebugState(PhysicsAdaptor::DebugState(csDebugState));
 450       }
 451       CALL_CATCH_EXCEPTION();
 452     }
 453   }
 454
 455   SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_GetDebugState(void* csAdaptor)
 456   {
 457     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 458     PhysicsAdaptor::DebugState result;
 459     if(!adaptor)
 460     {
 461       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 462       return 0;
 463     }
 464     {
 465       try
 466       {
 467         result = adaptor->GetDebugState();
 468       }
 469       CALL_CATCH_EXCEPTION(0);
 470     }
 471     return(int)result;
 472   }
 473
 474   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_AddActorBody(void* csAdaptor, void* csActor, void* csBody)
 475   {
 476     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 477     if(!adaptor)
 478     {
 479       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 480       return 0;
 481     }
 482     if(!csActor)
 483     {
 484       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
 485       return 0;
 486     }
 487     if(!csBody)
 488     {
 489       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "btRigidBody ptr is null", 0);
 490       return 0;
 491     }
 492
 493     PhysicsActor physicsActor;
 494     {
 495       try
 496       {
 497         physicsActor = adaptor->AddActorBody((const Dali::Actor&)*(Dali::Actor*)csActor, Dali::Any((btRigidBody*)csBody));
 498       }
 499       CALL_CATCH_EXCEPTION(0);
 500     }
 501     return new PhysicsActor((const PhysicsActor&)physicsActor);
 502   }
 503
 504   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_RemoveActorBody(void* csAdaptor, void* csPhysicsActor)
 505   {
 506     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 507     if(!adaptor)
 508     {
 509       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 510       return;
 511     }
 512     if(!csPhysicsActor)
 513     {
 514       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsActor const & type is null", 0);
 515       return;
 516     }
 517
 518     {
 519       try
 520       {
 521         adaptor->RemoveActorBody((const PhysicsActor&)*(PhysicsActor*)csPhysicsActor);
 522       }
 523       CALL_CATCH_EXCEPTION();
 524     }
 525     return;
 526   }
 527
 528   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_GetPhysicsActor(void* csAdaptor, void* csBody)
 529   {
 530     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 531     if(!adaptor)
 532     {
 533       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 534       return 0;
 535     }
 536     if(!csBody)
 537     {
 538       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "btRigidBody ptr type is null", 0);
 539       return 0;
 540     }
 541
 542     PhysicsActor physicsActor;
 543     {
 544       try
 545       {
 546         physicsActor = adaptor->GetPhysicsActor((Dali::Any((btRigidBody*)csBody)));
 547       }
 548       CALL_CATCH_EXCEPTION(0);
 549     }
 550     return new PhysicsActor((const PhysicsActor&)physicsActor);
 551   }
 552
 553
 554   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_GetRootActor(void* csAdaptor)
 555   {
 556     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 557     if(!adaptor)
 558     {
 559       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 560       return 0;
 561     }
 562
 563     Dali::Actor actor;
 564     {
 565       try
 566       {
 567         actor = adaptor->GetRootActor();
 568       }
 569       CALL_CATCH_EXCEPTION(0);
 570     }
 571     return new Dali::Actor((const Dali::Actor&)actor);
 572   }
 573
 574   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_BuildPickingRay(void* csAdaptor,
 575                                                                          void* csOrigin,
 576                                                                          void* csDirection,
 577                                                                          void* csRayFromWorld,
 578                                                                          void* csRayToWorld)
 579   {
 580     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 581     if(!adaptor)
 582     {
 583       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 584       return;
 585     }
 586     if(!csOrigin)
 587     {
 588       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 589       return;
 590     }
 591     if(!csDirection)
 592     {
 593       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 594       return;
 595     }
 596     if(!csRayFromWorld)
 597     {
 598       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 599       return;
 600     }
 601     if(!csRayToWorld)
 602     {
 603       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 604       return;
 605     }
 606
 607     try
 608     {
 609       adaptor->BuildPickingRay(*(Dali::Vector3*)(csOrigin),
 610                                *(Dali::Vector3*)(csDirection),
 611                                *(Dali::Vector3*)(csRayFromWorld),
 612                                *(Dali::Vector3*)(csRayToWorld));
 613     }
 614     CALL_CATCH_EXCEPTION();
 615   }
 616
 617   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_ProjectPoint(void* csAdaptor,
 618                                                                        void* csOrigin,
 619                                                                        void* csDirection,
 620                                                                        float distance)
 621   {
 622     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 623     if(!adaptor)
 624     {
 625       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 626       return 0;
 627     }
 628     if(!csOrigin)
 629     {
 630       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 631       return 0;
 632     }
 633     if(!csDirection)
 634     {
 635       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
 636       return 0;
 637     }
 638     Dali::Vector3 point;
 639     try
 640     {
 641       point = adaptor->ProjectPoint(*(Dali::Vector3*)(csOrigin),
 642                                     *(Dali::Vector3*)(csDirection),
 643                                     distance);
 644
 645     }
 646     CALL_CATCH_EXCEPTION(0);
 647     return new Dali::Vector3((const Dali::Vector3&)point);
 648   }
 649
 650   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_CreateSyncPoint(void* csAdaptor)
 651   {
 652     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 653     if(!adaptor)
 654     {
 655       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 656       return;
 657     }
 658     {
 659       try
 660       {
 661         adaptor->CreateSyncPoint();
 662       }
 663       CALL_CATCH_EXCEPTION();
 664     }
 665   }
 666
 667   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsAdaptor_GetPhysicsWorld(void* csAdaptor)
 668   {
 669     PhysicsAdaptor* adaptor = (PhysicsAdaptor*)csAdaptor;
 670     if(!adaptor)
 671     {
 672       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsAdaptor const & type is null", 0);
 673       return 0;
 674     }
 675
 676     Dali::Toolkit::Physics::Integration::PhysicsWorld result{nullptr};
 677     {
 678       try
 679       {
 680
 681         result = Dali::Toolkit::Physics::Integration::GetPhysicsWorld(*adaptor);
 682       }
 683       CALL_CATCH_EXCEPTION(0);
 684     }
 685     return result.GetImpl();
 686   }
 687
 688
 689   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PhysicsWorld_Lock(void* csWorld)
 690   {
 691     if(!csWorld)
 692     {
 693       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsWorld const ref type is null",0);
 694       return;
 695     }
 696     {
 697       try
 698       {
 699         Dali::Toolkit::Physics::Integration::PhysicsWorld world(static_cast<Dali::Toolkit::Physics::Internal::PhysicsWorld*>(csWorld));
 700         world.Lock();
 701       }
 702       CALL_CATCH_EXCEPTION();
 703     }
 704   }
 705
 706   SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PhysicsWorld_Unlock(void* csWorld)
 707   {
 708     if(!csWorld)
 709     {
 710       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsWorld const ref type is null",0);
 711       return;
 712     }
 713     {
 714       try
 715       {
 716         Dali::Toolkit::Physics::Integration::PhysicsWorld world(static_cast<Dali::Toolkit::Physics::Internal::PhysicsWorld*>(csWorld));
 717         world.Unlock();
 718       }
 719       CALL_CATCH_EXCEPTION();
 720     }
 721   }
 722
 723
 724   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsWorld_GetNative(void* csWorld)
 725   {
 726     if(!csWorld)
 727     {
 728       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsWorld const ref type is null",0);
 729       return 0;
 730     }
 731     Dali::Any physicsWorld;
 732     {
 733       try
 734       {
 735         Dali::Toolkit::Physics::Integration::PhysicsWorld world(static_cast<Dali::Toolkit::Physics::Internal::PhysicsWorld*>(csWorld));
 736         physicsWorld = world.GetNative();
 737       }
 738       CALL_CATCH_EXCEPTION(0);
 739     }
 740     if(!physicsWorld.Empty())
 741     {
 742       return physicsWorld.Get<btDiscreteDynamicsWorld*>();
 743     }
 744     return nullptr;
 745   }
 746
 747   SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PhysicsWorld_HitTest(void* csWorld, Dali::Vector3* rayFromWorld, Dali::Vector3* rayToWorld, void* localPivot, void* distanceFromCamera)
 748   {
 749     if(!csWorld)
 750     {
 751       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PhysicsWorld const ref type is null",0);
 752       return 0;
 753     }
 754     if(!rayFromWorld)
 755     {
 756       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Vector3 const ref type is null",0);
 757       return 0;
 758     }
 759     if(!rayToWorld)
 760     {
 761       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Vector3 const ref type is null",0);
 762       return 0;
 763     }
 764     if(!localPivot)
 765     {
 766       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Vector3 ref type is null",0);
 767       return 0;
 768     }
 769     if(!distanceFromCamera)
 770     {
 771       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "float ref type is null",0);
 772       return 0;
 773     }
 774
 775     Dali::Vector3 myLocalPivot;
 776     float myDistanceFromCamera;
 777     Dali::Any result;
 778     {
 779       try
 780       {
 781         Dali::Any shapeFilter;
 782
 783         Dali::Toolkit::Physics::Integration::PhysicsWorld world(static_cast<Dali::Toolkit::Physics::Internal::PhysicsWorld*>(csWorld));
 784         result = world.HitTest(*rayFromWorld, *rayToWorld, shapeFilter, myLocalPivot, myDistanceFromCamera);
 785       }
 786       CALL_CATCH_EXCEPTION(0);
 787     }
 788
 789     if(!result.Empty())
 790     {
 791       if(localPivot != nullptr)
 792       {
 793         *(static_cast<Dali::Vector3*>(localPivot)) = myLocalPivot;
 794       }
 795       if(distanceFromCamera != nullptr)
 796       {
 797         *(static_cast<float*>(distanceFromCamera)) = myDistanceFromCamera;
 798       }
 799       return result.Get<btRigidBody*>();
 800     }
 801     return nullptr;
 802   }
 803
 804
 805
 806   // Lowest priority
 807   //void Queue(std::function<void(void)> function);
 808
 809
 810 #ifdef __cplusplus
 811 }
 812 #endif