dali-csharp-binder/dali-toolkit/particle-system-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  *d
   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-toolkit/public-api/particle-system/particle-domain.h>
  20 #include <dali-toolkit/public-api/particle-system/particle-emitter.h>
  21 #include <dali-toolkit/public-api/particle-system/particle-list.h>
  22 #include <dali-toolkit/public-api/particle-system/particle-modifier.h>
  23 #include <dali-toolkit/public-api/particle-system/particle-renderer.h>
  24 #include <dali-toolkit/public-api/particle-system/particle-source.h>
  25 #include <dali-toolkit/public-api/particle-system/particle.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-csharp-binder/common/common.h>
  29
  30 #ifdef __cplusplus
  31 extern "C" {
  32 #endif
  33
  34 using namespace Dali::Toolkit::ParticleSystem;
  35
  36 /**
  37  * Generic ParticleSource for NUI apps
  38  */
  39
  40 typedef void (*SourceInitCallbackInvoker)(void*);
  41 typedef uint32_t (*SourceUpdateCallbackInvoker)(void*, uint32_t); // delegate, parameters
  42 class ParticleSourceNUI : public Dali::Toolkit::ParticleSystem::ParticleSourceInterface
  43 {
  44 public:
  45   ParticleSourceNUI(SourceInitCallbackInvoker onInitDelegate, SourceUpdateCallbackInvoker onUpdateDelegate)
  46   {
  47     mOnInitInvoker   = onInitDelegate;
  48     mOnUpdateInvoker = onUpdateDelegate;
  49   }
  50
  51   void SetBaseObjectPtr(void* basePtr)
  52   {
  53     mBaseObjectPtr = basePtr;
  54   }
  55
  56   uint32_t Update(ParticleList& outList, uint32_t count) override
  57   {
  58     // NUI side must use EmitterProxy.NewParticle() to create new particle
  59     return mOnUpdateInvoker(mBaseObjectPtr, count);
  60   }
  61
  62   /**
  63    * @brief Called when source is added to the emitter
  64    */
  65   void Init() override
  66   {
  67     mOnInitInvoker(mBaseObjectPtr);
  68   }
  69
  70   static SourceInitCallbackInvoker   mOnInitInvoker;
  71   static SourceUpdateCallbackInvoker mOnUpdateInvoker;
  72
  73   void* mBaseObjectPtr;
  74 };
  75
  76 typedef void (*ModifierUpdateCallbackInvoker)(void*, void*, uint32_t, uint32_t); // delegate, parameters
  77 class ParticleModifierNUI : public Dali::Toolkit::ParticleSystem::ParticleModifierInterface
  78 {
  79 public:
  80   ParticleModifierNUI(ModifierUpdateCallbackInvoker onUpdateDelegate)
  81   {
  82     mOnUpdateInvoker = onUpdateDelegate;
  83   }
  84
  85   void SetBaseObjectPtr(void* basePtr)
  86   {
  87     mBaseObjectPtr = basePtr;
  88   }
  89
  90   void Update(ParticleList& outList, uint32_t firstParticleIndex, uint32_t count) override
  91   {
  92     // mOnUpdateInvoker(mBaseObjectPtr, new ParticleList(outList), firstParticleIndex, count);
  93     std::vector<int32_t> ptrList;
  94     ptrList.reserve(count);
  95     auto& particleList = outList.GetActiveParticles();
  96     for(auto& item : particleList)
  97     {
  98       ptrList.emplace_back(item.GetIndex());
  99     }
 100     mOnUpdateInvoker(mBaseObjectPtr, ptrList.data(), firstParticleIndex, count);
 101   }
 102
 103   static ModifierUpdateCallbackInvoker mOnUpdateInvoker;
 104   void*                                mBaseObjectPtr;
 105 };
 106
 107 extern "C++" SourceInitCallbackInvoker     ParticleSourceNUI::mOnInitInvoker;
 108 extern "C++" SourceUpdateCallbackInvoker   ParticleSourceNUI::mOnUpdateInvoker;
 109 extern "C++" ModifierUpdateCallbackInvoker ParticleModifierNUI::mOnUpdateInvoker;
 110
 111 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleEmitter_New_SWIG_0(void* csView)
 112 {
 113   ParticleEmitter result;
 114   {
 115     try
 116     {
 117       result = ParticleEmitter::New();
 118       result.AttachTo(*(Dali::Actor*)csView);
 119
 120       // Create internal renderer (not exposed to C#)
 121       ParticleRenderer renderer = ParticleRenderer::New();
 122       result.SetRenderer(renderer);
 123
 124       // Add dummy particle domain (not supported in NUI) so emitter won't cry
 125       ParticleDomain domain = ParticleDomain::New();
 126       result.SetDomain(domain);
 127     }
 128     CALL_CATCH_EXCEPTION(0);
 129   }
 130
 131   return new ParticleEmitter((const ParticleEmitter&)result);
 132 }
 133
 134 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ParticleEmitter_SWIG_0()
 135 {
 136   ParticleEmitter* result = 0;
 137
 138   {
 139     try
 140     {
 141       result = (ParticleEmitter*)new ParticleEmitter();
 142     }
 143     CALL_CATCH_EXCEPTION(0);
 144   }
 145   return (void*)result;
 146 }
 147
 148 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ParticleEmitter_SWIG_1(void* csParticleEmitter)
 149 {
 150   ParticleEmitter* particleEmitter = (ParticleEmitter*)csParticleEmitter;
 151   ParticleEmitter* result          = 0;
 152
 153   if(!particleEmitter)
 154   {
 155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ParticleEmitter const & type is null", 0);
 156     return 0;
 157   }
 158   {
 159     try
 160     {
 161       result = (ParticleEmitter*)new ParticleEmitter((ParticleEmitter const&)*particleEmitter);
 162     }
 163     CALL_CATCH_EXCEPTION(0);
 164   }
 165
 166   return (void*)result;
 167 }
 168
 169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ParticleEmitter(void* csParticleEmitter)
 170 {
 171   ParticleEmitter* particleEmitter = (ParticleEmitter*)csParticleEmitter;
 172   {
 173     try
 174     {
 175       delete particleEmitter;
 176     }
 177     CALL_CATCH_EXCEPTION();
 178   }
 179 }
 180
 181 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleEmitter_Assign(void* csDestination, void* csSource)
 182 {
 183   ParticleEmitter* destination = (ParticleEmitter*)csDestination;
 184   ParticleEmitter* source      = (ParticleEmitter*)csSource;
 185   ParticleEmitter* result      = 0;
 186
 187   if(!source)
 188   {
 189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ParticleEmitter const & type is null", 0);
 190     return 0;
 191   }
 192   {
 193     try
 194     {
 195       result = (ParticleEmitter*)&(destination)->operator=((ParticleEmitter const&)*source);
 196     }
 197     CALL_CATCH_EXCEPTION(0);
 198   }
 199
 200   return (void*)result;
 201 }
 202
 203 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_particleEmitter_DownCast(void* csHandle)
 204 {
 205   Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle;
 206   ParticleEmitter   result;
 207
 208   if(!handle)
 209   {
 210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 211     return 0;
 212   }
 213   {
 214     try
 215     {
 216       result = ParticleEmitter::DownCast(*handle);
 217     }
 218     CALL_CATCH_EXCEPTION(0);
 219   }
 220
 221   return new ParticleEmitter((const ParticleEmitter&)result);
 222 }
 223
 224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_SetSource(void* csThis, void* csSource)
 225 {
 226   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 227   ParticleSource*  source  = (ParticleSource*)csSource;
 228
 229   if(!emitter)
 230   {
 231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 232     return;
 233   }
 234   if(!csSource)
 235   {
 236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleSource", 0);
 237     return;
 238   }
 239   {
 240     try
 241     {
 242       puts("Setting source");
 243       emitter->SetSource(*source);
 244       puts("souirce set");
 245     }
 246     CALL_CATCH_EXCEPTION();
 247   }
 248 }
 249
 250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_SetDomain(void* csThis, void* csDomain)
 251 {
 252   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 253   ParticleDomain*  domain  = (ParticleDomain*)csDomain;
 254
 255   if(!emitter)
 256   {
 257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 258     return;
 259   }
 260   if(!csDomain)
 261   {
 262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleDomain", 0);
 263     return;
 264   }
 265   {
 266     try
 267     {
 268       emitter->SetDomain(*domain);
 269     }
 270     CALL_CATCH_EXCEPTION();
 271   }
 272 }
 273
 274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_SetRenderer(void* csThis, void* csRenderer)
 275 {
 276   ParticleEmitter*  emitter  = (ParticleEmitter*)csThis;
 277   ParticleRenderer* renderer = (ParticleRenderer*)csRenderer;
 278
 279   if(!emitter)
 280   {
 281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 282     return;
 283   }
 284   if(!csRenderer)
 285   {
 286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleRenderer", 0);
 287     return;
 288   }
 289   {
 290     try
 291     {
 292       emitter->SetRenderer(*renderer);
 293     }
 294     CALL_CATCH_EXCEPTION();
 295   }
 296 }
 297
 298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_SetParticleCount(void* csThis, uint32_t count)
 299 {
 300   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 301   if(!emitter)
 302   {
 303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 304     return;
 305   }
 306   {
 307     try
 308     {
 309       emitter->SetParticleCount(count);
 310     }
 311     CALL_CATCH_EXCEPTION();
 312   }
 313 }
 314
 315 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_ParticleEmitter_GetParticleCount(void* csThis)
 316 {
 317   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 318   if(!emitter)
 319   {
 320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 321     return 0;
 322   }
 323   {
 324     try
 325     {
 326       return emitter->GetParticleCount();
 327     }
 328     CALL_CATCH_EXCEPTION(0);
 329   }
 330 }
 331
 332 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleEmitter_GetSource(void* csThis)
 333 {
 334   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 335   ParticleSource   source;
 336   if(!emitter)
 337   {
 338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 339     return 0;
 340   }
 341   {
 342     try
 343     {
 344       source = emitter->GetSource();
 345     }
 346     CALL_CATCH_EXCEPTION(0);
 347   }
 348
 349   ParticleSource* result = new ParticleSource((const ParticleSource&)source);
 350   return result;
 351 }
 352
 353 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleEmitter_GetDomain(void* csThis)
 354 {
 355   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 356   ParticleDomain   domain;
 357   if(!emitter)
 358   {
 359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 360     return 0;
 361   }
 362   {
 363     try
 364     {
 365       domain = emitter->GetDomain();
 366     }
 367     CALL_CATCH_EXCEPTION(0);
 368   }
 369
 370   ParticleDomain* result = new ParticleDomain((const ParticleDomain&)domain);
 371   return result;
 372 }
 373
 374 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleEmitter_GetRenderer(void* csThis)
 375 {
 376   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 377   ParticleRenderer renderer;
 378   if(!emitter)
 379   {
 380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 381     return 0;
 382   }
 383   {
 384     try
 385     {
 386       renderer = emitter->GetRenderer();
 387     }
 388     CALL_CATCH_EXCEPTION(0);
 389   }
 390
 391   ParticleRenderer* result = new ParticleRenderer((const ParticleRenderer&)renderer);
 392   return result;
 393 }
 394
 395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_AddModifier(void* csThis, void* csModifier)
 396 {
 397   ParticleEmitter*  emitter  = (ParticleEmitter*)csThis;
 398   ParticleModifier* modifier = (ParticleModifier*)csModifier;
 399
 400   if(!emitter)
 401   {
 402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 403     return;
 404   }
 405   if(!csModifier)
 406   {
 407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleModifier", 0);
 408     return;
 409   }
 410   {
 411     try
 412     {
 413       emitter->AddModifier(*modifier);
 414     }
 415     CALL_CATCH_EXCEPTION();
 416   }
 417 }
 418
 419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_SetEmissionRate(void* csThis, uint32_t ratePerSecond)
 420 {
 421   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 422   if(!emitter)
 423   {
 424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 425     return;
 426   }
 427   {
 428     try
 429     {
 430       emitter->SetEmissionRate(ratePerSecond);
 431     }
 432     CALL_CATCH_EXCEPTION();
 433   }
 434 }
 435
 436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_SetInitialParticleCount(void* csThis, uint32_t count)
 437 {
 438   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 439   if(!emitter)
 440   {
 441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 442     return;
 443   }
 444   {
 445     try
 446     {
 447       emitter->SetInitialParticleCount(count);
 448     }
 449     CALL_CATCH_EXCEPTION();
 450   }
 451 }
 452
 453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_SetActiveParticlesLimit(void* csThis, uint32_t limit)
 454 {
 455   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 456   if(!emitter)
 457   {
 458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 459     return;
 460   }
 461   {
 462     try
 463     {
 464       emitter->SetActiveParticlesLimit(limit);
 465     }
 466     CALL_CATCH_EXCEPTION();
 467   }
 468 }
 469
 470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_Start(void* csThis)
 471 {
 472   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 473   if(!emitter)
 474   {
 475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 476     return;
 477   }
 478   {
 479     try
 480     {
 481       emitter->Start();
 482     }
 483     CALL_CATCH_EXCEPTION();
 484   }
 485 }
 486
 487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_Stop(void* csThis)
 488 {
 489   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 490   if(!emitter)
 491   {
 492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 493     return;
 494   }
 495   {
 496     try
 497     {
 498       emitter->Stop();
 499     }
 500     CALL_CATCH_EXCEPTION();
 501   }
 502 }
 503
 504 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_ParticleEmitter_GetEmissionRate(void* csThis)
 505 {
 506   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 507   if(!emitter)
 508   {
 509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 510     return 0;
 511   }
 512   {
 513     try
 514     {
 515       return emitter->GetEmissionRate();
 516     }
 517     CALL_CATCH_EXCEPTION(0);
 518   }
 519 }
 520
 521 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_ParticleEmitter_GetInitialParticleCount(void* csThis)
 522 {
 523   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 524   if(!emitter)
 525   {
 526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 527     return 0;
 528   }
 529   {
 530     try
 531     {
 532       return emitter->GetInitialParticleCount();
 533     }
 534     CALL_CATCH_EXCEPTION(0);
 535   }
 536 }
 537
 538 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_ParticleEmitter_GetActiveParticleLimit(void* csThis)
 539 {
 540   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 541   if(!emitter)
 542   {
 543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 544     return 0;
 545   }
 546   {
 547     try
 548     {
 549       return emitter->GetActiveParticlesLimit();
 550     }
 551     CALL_CATCH_EXCEPTION(0);
 552   }
 553 }
 554
 555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleEmitter_RemoveModifierAt(void* csThis, uint32_t location)
 556 {
 557   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 558   if(!emitter)
 559   {
 560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 561     return;
 562   }
 563   {
 564     try
 565     {
 566       emitter->RemoveModifierAt(location);
 567     }
 568     CALL_CATCH_EXCEPTION();
 569   }
 570 }
 571
 572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ParticleEmitter_NewParticle(void* csEmitter, float lifetime)
 573 {
 574   ParticleEmitter* emitter = (ParticleEmitter*)csEmitter;
 575   if(!emitter)
 576   {
 577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 578     return -1;
 579   }
 580   {
 581     try
 582     {
 583       Particle p = emitter->GetParticleList().NewParticle(lifetime);
 584       return int(p.GetIndex());
 585     }
 586     CALL_CATCH_EXCEPTION(-1);
 587   }
 588 }
 589
 590 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleEmitter_GetParticleList(void* csThis)
 591 {
 592   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 593   ParticleList     list;
 594   if(!emitter)
 595   {
 596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
 597     return 0;
 598   }
 599   {
 600     try
 601     {
 602       list = emitter->GetParticleList();
 603     }
 604     CALL_CATCH_EXCEPTION(0);
 605   }
 606
 607   ParticleList* result = new ParticleList((const ParticleList&)list);
 608   return result;
 609 }
 610
 611 // void AttachTo(Actor actor);
 612 //[[nodiscard]] Status GetStatus() const;
 613
 614 // Class: ParticleSource
 615 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleSource_New_SWIG_0(SourceInitCallbackInvoker onInitInvoker, SourceUpdateCallbackInvoker onUpdateInvoker, void** refObject)
 616 {
 617   ParticleSource result;
 618   {
 619     try
 620     {
 621       result     = ParticleSource::New<ParticleSourceNUI>(onInitInvoker, onUpdateInvoker);
 622       auto& clbk = static_cast<ParticleSourceNUI&>(result.GetSourceCallback());
 623       clbk.SetBaseObjectPtr(result.GetObjectPtr());
 624       *refObject = result.GetObjectPtr();
 625     }
 626     CALL_CATCH_EXCEPTION(0);
 627   }
 628
 629   return new ParticleSource((const ParticleSource&)result);
 630 }
 631
 632 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ParticleSource_SWIG_0()
 633 {
 634   ParticleSource* result = 0;
 635
 636   {
 637     try
 638     {
 639       result = (ParticleSource*)new ParticleSource();
 640     }
 641     CALL_CATCH_EXCEPTION(0);
 642   }
 643
 644   return (void*)result;
 645 }
 646
 647 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ParticleSource_SWIG_1(void* csParticleSource)
 648 {
 649   ParticleSource* particleEmitter = (ParticleSource*)csParticleSource;
 650   ParticleSource* result          = 0;
 651
 652   if(!particleEmitter)
 653   {
 654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ParticleSource const & type is null", 0);
 655     return 0;
 656   }
 657   {
 658     try
 659     {
 660       result = (ParticleSource*)new ParticleSource((ParticleSource const&)*particleEmitter);
 661     }
 662     CALL_CATCH_EXCEPTION(0);
 663   }
 664
 665   return (void*)result;
 666 }
 667
 668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ParticleSource(void* csParticleSource)
 669 {
 670   ParticleSource* particleEmitter = (ParticleSource*)csParticleSource;
 671   {
 672     try
 673     {
 674       delete particleEmitter;
 675     }
 676     CALL_CATCH_EXCEPTION();
 677   }
 678 }
 679
 680 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleSource_Assign(void* csDestination, void* csSource)
 681 {
 682   ParticleSource* destination = (ParticleSource*)csDestination;
 683   ParticleSource* source      = (ParticleSource*)csSource;
 684   ParticleSource* result      = 0;
 685
 686   if(!source)
 687   {
 688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ParticleSource const & type is null", 0);
 689     return 0;
 690   }
 691   {
 692     try
 693     {
 694       result = (ParticleSource*)&(destination)->operator=((ParticleSource const&)*source);
 695     }
 696     CALL_CATCH_EXCEPTION(0);
 697   }
 698
 699   return (void*)result;
 700 }
 701
 702 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleSource_DownCast(void* csHandle)
 703 {
 704   Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle;
 705   ParticleSource    result;
 706
 707   if(!handle)
 708   {
 709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleSource", 0);
 710     return 0;
 711   }
 712   {
 713     try
 714     {
 715       result = ParticleSource::DownCast(*handle);
 716     }
 717     CALL_CATCH_EXCEPTION(0);
 718   }
 719
 720   return new ParticleSource((const ParticleSource&)result);
 721 }
 722
 723 // Class: ParticleModifier
 724 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleModifier_New_SWIG_0(ModifierUpdateCallbackInvoker onUpdateInvoker, void** basePtr)
 725 {
 726   ParticleModifier result;
 727   {
 728     try
 729     {
 730       result     = ParticleModifier::New<ParticleModifierNUI>(onUpdateInvoker);
 731       auto& clbk = static_cast<ParticleModifierNUI&>(result.GetModifierCallback());
 732       clbk.SetBaseObjectPtr(result.GetObjectPtr());
 733       *basePtr = result.GetObjectPtr();
 734       printf("BasePtr: %p\n", *basePtr);
 735     }
 736     CALL_CATCH_EXCEPTION(0);
 737   }
 738
 739   return new ParticleModifier((const ParticleModifier&)result);
 740 }
 741
 742 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ParticleModifier_SWIG_0()
 743 {
 744   ParticleModifier* result = 0;
 745
 746   {
 747     try
 748     {
 749       result = (ParticleModifier*)new ParticleModifier();
 750     }
 751     CALL_CATCH_EXCEPTION(0);
 752   }
 753
 754   return (void*)result;
 755 }
 756
 757 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ParticleModifier_SWIG_1(void* csParticleModifier)
 758 {
 759   ParticleModifier* particleEmitter = (ParticleModifier*)csParticleModifier;
 760   ParticleModifier* result          = 0;
 761
 762   if(!particleEmitter)
 763   {
 764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ParticleModifier const & type is null", 0);
 765     return 0;
 766   }
 767   {
 768     try
 769     {
 770       result = (ParticleModifier*)new ParticleModifier((ParticleModifier const&)*particleEmitter);
 771     }
 772     CALL_CATCH_EXCEPTION(0);
 773   }
 774
 775   return (void*)result;
 776 }
 777
 778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ParticleModifier(void* csParticleModifier)
 779 {
 780   ParticleModifier* particleEmitter = (ParticleModifier*)csParticleModifier;
 781   {
 782     try
 783     {
 784       delete particleEmitter;
 785     }
 786     CALL_CATCH_EXCEPTION();
 787   }
 788 }
 789
 790 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleModifier_Assign(void* csDestination, void* csSource)
 791 {
 792   ParticleModifier* destination = (ParticleModifier*)csDestination;
 793   ParticleModifier* source      = (ParticleModifier*)csSource;
 794   ParticleModifier* result      = 0;
 795
 796   if(!source)
 797   {
 798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ParticleModifier const & type is null", 0);
 799     return 0;
 800   }
 801   {
 802     try
 803     {
 804       result = (ParticleModifier*)&(destination)->operator=((ParticleModifier const&)*source);
 805     }
 806     CALL_CATCH_EXCEPTION(0);
 807   }
 808
 809   return (void*)result;
 810 }
 811
 812 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleModifier_DownCast(void* csHandle)
 813 {
 814   Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle;
 815   ParticleModifier  result;
 816
 817   if(!handle)
 818   {
 819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleModifier", 0);
 820     return 0;
 821   }
 822   {
 823     try
 824     {
 825       result = ParticleModifier::DownCast(*handle);
 826     }
 827     CALL_CATCH_EXCEPTION(0);
 828   }
 829
 830   return new ParticleModifier((const ParticleModifier&)result);
 831 }
 832
 833 // Class: ParticleList
 834 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleList_New_SWIG_0(void* csEmitter)
 835 {
 836   ParticleEmitter* emitter = (ParticleEmitter*)csEmitter;
 837   auto             result  = emitter->GetParticleList();
 838
 839   printf("CSharp_Dali_ParticleList_New_SWIG_0: %p", result.GetObjectPtr());
 840
 841   return new ParticleList((const ParticleList&)result);
 842 }
 843
 844 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ParticleList_SWIG_0()
 845 {
 846   ParticleList* result = 0;
 847
 848   {
 849     try
 850     {
 851       result = (ParticleList*)new ParticleList();
 852     }
 853     CALL_CATCH_EXCEPTION(0);
 854   }
 855
 856   return (void*)result;
 857 }
 858
 859 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ParticleList_SWIG_1(void* csParticleList)
 860 {
 861   ParticleList* particleEmitter = (ParticleList*)csParticleList;
 862   ParticleList* result          = 0;
 863
 864   if(!particleEmitter)
 865   {
 866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ParticleList const & type is null", 0);
 867     return 0;
 868   }
 869   {
 870     try
 871     {
 872       result = (ParticleList*)new ParticleList((ParticleList const&)*particleEmitter);
 873     }
 874     CALL_CATCH_EXCEPTION(0);
 875   }
 876
 877   return (void*)result;
 878 }
 879
 880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ParticleList(void* csParticleList)
 881 {
 882   ParticleList* particleEmitter = (ParticleList*)csParticleList;
 883   {
 884     try
 885     {
 886       delete particleEmitter;
 887     }
 888     CALL_CATCH_EXCEPTION();
 889   }
 890 }
 891
 892 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleList_Assign(void* csDestination, void* csSource)
 893 {
 894   ParticleList* destination = (ParticleList*)csDestination;
 895   ParticleList* source      = (ParticleList*)csSource;
 896   ParticleList* result      = 0;
 897
 898   if(!source)
 899   {
 900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ParticleList const & type is null", 0);
 901     return 0;
 902   }
 903   {
 904     try
 905     {
 906       result = (ParticleList*)&(destination)->operator=((ParticleList const&)*source);
 907     }
 908     CALL_CATCH_EXCEPTION(0);
 909   }
 910
 911   return (void*)result;
 912 }
 913
 914 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ParticleList_DownCast(void* csHandle)
 915 {
 916   Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle;
 917   ParticleList      result;
 918
 919   if(!handle)
 920   {
 921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleList", 0);
 922     return 0;
 923   }
 924   {
 925     try
 926     {
 927       result = ParticleList::DownCast(*handle);
 928     }
 929     CALL_CATCH_EXCEPTION(0);
 930   }
 931
 932   return new ParticleList((const ParticleList&)result);
 933 }
 934
 935 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_ParticleList_GetParticle(void* csThis, uint32_t index)
 936 {
 937   ParticleList* list = (ParticleList*)csThis;
 938   Particle      particle;
 939   if(!list)
 940   {
 941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleList", 0);
 942     return 0;
 943   }
 944   {
 945     try
 946     {
 947       // Must be better way of doing it?
 948       auto it = list->GetActiveParticles().begin();
 949       std::advance(it, index);
 950       particle = *it;
 951     }
 952     CALL_CATCH_EXCEPTION(0);
 953   }
 954
 955   return particle.GetIndex();
 956 }
 957
 958 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_ParticleList_GetActiveParticleCount(void* csThis)
 959 {
 960   ParticleList* list = (ParticleList*)csThis;
 961   if(!list)
 962   {
 963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleList", 0);
 964     return 0;
 965   }
 966   {
 967     try
 968     {
 969       return list->GetActiveParticleCount();
 970     }
 971     CALL_CATCH_EXCEPTION(0);
 972   }
 973 }
 974
 975 SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_ParticleList_AddLocalStream(void* csThis, uint32_t streamType, void* defaultValue, uint32_t typeSize)
 976 {
 977   enum class StreamType
 978   {
 979     FLOAT   = 0,
 980     FVEC2   = 1,
 981     FVEC3   = 2,
 982     FVEC4   = 3,
 983     INTEGER = 4,
 984     IVEC2   = 5,
 985     IVEC3   = 6,
 986     IVEC4   = 7,
 987   };
 988   ParticleEmitter* emitter = (ParticleEmitter*)csThis;
 989   uint32_t         result  = 0;
 990   if(!emitter)
 991   {
 992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleList", 0);
 993     return 0;
 994   }
 995   auto list = emitter->GetParticleList();
 996   {
 997     try
 998     {
 999       switch(StreamType(streamType))
1000       {
1001         case StreamType::FLOAT: {
1002           result = list.AddLocalStream<float>(*reinterpret_cast<float*>(defaultValue));
1003           break;
1004         }
1005         case StreamType::FVEC2:
1006           result = list.AddLocalStream<Dali::Vector2>(*reinterpret_cast<Dali::Vector2*>((Dali::Vector2*)defaultValue));
1007           break;
1008         case StreamType::FVEC3: {
1009           result = list.AddLocalStream<Dali::Vector3>(*reinterpret_cast<Dali::Vector3*>((Dali::Vector3*)defaultValue));
1010           break;
1011         }
1012         case StreamType::FVEC4:
1013           result = list.AddLocalStream<Dali::Vector4>(*reinterpret_cast<Dali::Vector4*>((Dali::Vector4*)defaultValue));
1014           break;
1015         case StreamType::INTEGER:
1016           result = list.AddLocalStream<int>(*reinterpret_cast<int*>(defaultValue));
1017           break;
1018         case StreamType::IVEC2:
1019           // unsupported
1020           break;
1021         case StreamType::IVEC3:
1022           // unsupported
1023           break;
1024         case StreamType::IVEC4:
1025           // unsupported
1026           break;
1027       }
1028     }
1029     CALL_CATCH_EXCEPTION(0);
1030   }
1031
1032   return result;
1033 }
1034
1035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ParticleList_GetDefaultStreamIndex(void* csThis, uint32_t defaultStream)
1036 {
1037   auto* emitter = (ParticleEmitter*)csThis;
1038   int   result  = 0;
1039   if(!emitter)
1040   {
1041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleList", 0);
1042     return 0;
1043   }
1044   auto list = emitter->GetParticleList();
1045   {
1046     try
1047     {
1048       result = list.GetDefaultStreamIndex(defaultStream);
1049     }
1050     CALL_CATCH_EXCEPTION(-1);
1051   }
1052
1053   return result;
1054 }
1055
1056 // uint32_t GetActiveParticleCount();
1057 //  [[nodiscard]] uint32_t GetCapacity() const;
1058 //  Particle NewParticle(float lifetime);
1059 // uint32_t GetParticleDataSize(bool includeLocalStreams);
1060 // GetParticleAt
1061 // std::list<Particle>& GetActiveParticles();
1062
1063 // Particle specific API (only C#)
1064 extern "C++" template<class T>
1065 SWIGEXPORT const T& SWIGSTDCALL CSharp_Dali_Particle_ReadValue(void* csEmitter, uint32_t streamIndex, uint32_t particleIndex)
1066 {
1067   ParticleEmitter* emitter = (ParticleEmitter*)csEmitter;
1068   static T         null{};
1069   if(!emitter)
1070   {
1071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
1072     return null;
1073   }
1074   auto particleList = emitter->GetParticleList();
1075
1076   return particleList.GetStream<T>(streamIndex)[particleIndex];
1077 }
1078
1079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Particle_ReadFloat(void* csThis, uint32_t streamIndex, uint32_t particleIndex)
1080 {
1081   return CSharp_Dali_Particle_ReadValue<float>(csThis, streamIndex, particleIndex);
1082 }
1083
1084 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Particle_ReadVector2(void* csThis, uint32_t streamIndex, uint32_t particleIndex)
1085 {
1086   return new Dali::Vector2(CSharp_Dali_Particle_ReadValue<Dali::Vector2>(csThis, streamIndex, particleIndex));
1087 }
1088
1089 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Particle_ReadVector3(void* csThis, uint32_t streamIndex, uint32_t particleIndex)
1090 {
1091   return new Dali::Vector3(CSharp_Dali_Particle_ReadValue<Dali::Vector3>(csThis, streamIndex, particleIndex));
1092 }
1093
1094 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Particle_ReadVector4(void* csThis, uint32_t streamIndex, uint32_t particleIndex)
1095 {
1096   return new Dali::Vector4(CSharp_Dali_Particle_ReadValue<Dali::Vector4>(csThis, streamIndex, particleIndex));
1097 }
1098
1099 // Writing value
1100 extern "C++" template<class T>
1101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Particle_WriteValue(void* csEmitter, uint32_t streamIndex, uint32_t particleIndex, T& value)
1102 {
1103   ParticleEmitter* emitter = (ParticleEmitter*)csEmitter;
1104   if(!emitter)
1105   {
1106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
1107     return;
1108   }
1109   auto particleList = emitter->GetParticleList();
1110   T*   r            = &(particleList.GetStream<T>(streamIndex)[particleIndex]);
1111   *r                = value;
1112 }
1113
1114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Particle_WriteFloat(void* csThis, uint32_t streamIndex, uint32_t particleIndex, float value)
1115 {
1116   CSharp_Dali_Particle_WriteValue(csThis, streamIndex, particleIndex, value);
1117 }
1118
1119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Particle_WriteVector2(void* csThis, uint32_t streamIndex, uint32_t particleIndex, Dali::Vector2* value)
1120 {
1121   CSharp_Dali_Particle_WriteValue(csThis, streamIndex, particleIndex, *value);
1122 }
1123
1124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Particle_WriteVector3(void* csThis, uint32_t streamIndex, uint32_t particleIndex, Dali::Vector3* value)
1125 {
1126   CSharp_Dali_Particle_WriteValue(csThis, streamIndex, particleIndex, *value);
1127 }
1128
1129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Particle_WriteVector4(void* csThis, uint32_t streamIndex, uint32_t particleIndex, Dali::Vector4* value)
1130 {
1131   CSharp_Dali_Particle_WriteValue(csThis, streamIndex, particleIndex, *value);
1132 }
1133
1134 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Particle_GetUnsafe(void* csThis, uint32_t streamIndex, uint32_t elementCount, uint32_t sizeOfElement)
1135 {
1136   Particle* particle = (Particle*)csThis;
1137   if(!particle)
1138   {
1139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Particle", 0);
1140     return 0;
1141   }
1142
1143   // For now
1144   if(sizeOfElement != 4)
1145   {
1146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Particle", 0);
1147     return 0;
1148   }
1149
1150   switch(elementCount)
1151   {
1152     case 1: {
1153       return &particle->Get<float>(streamIndex);
1154     }
1155     case 2: {
1156       return &particle->Get<Dali::Vector2>(streamIndex);
1157     }
1158     case 3: {
1159       return &particle->Get<Dali::Vector3>(streamIndex);
1160     }
1161     case 4: {
1162       return &particle->Get<Dali::Vector4>(streamIndex);
1163     }
1164     default:
1165       return 0;
1166   }
1167 }
1168 // Particle renderer
1169
1170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleRenderer_SetTexture(void* csEmitter, void* csTexture)
1171 {
1172   ParticleEmitter* emitter = (ParticleEmitter*)csEmitter;
1173   Dali::Texture*   texture = (Dali::Texture*)csTexture;
1174   ParticleRenderer result;
1175
1176   if(!emitter)
1177   {
1178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
1179     return;
1180   }
1181   {
1182     try
1183     {
1184       emitter->GetRenderer().SetTexture(*texture);
1185     }
1186     CALL_CATCH_EXCEPTION();
1187   }
1188 }
1189
1190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ParticleRenderer_SetBlendingMode(void* csEmitter, int blendingMode)
1191 {
1192   ParticleEmitter* emitter = (ParticleEmitter*)csEmitter;
1193   BlendingMode     mode    = BlendingMode(blendingMode);
1194
1195   if(!emitter)
1196   {
1197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
1198     return;
1199   }
1200   {
1201     try
1202     {
1203       emitter->GetRenderer().SetBlendingMode(mode);
1204     }
1205     CALL_CATCH_EXCEPTION();
1206   }
1207 }
1208
1209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ParticleRenderer_GetBlendingMode(void* csEmitter)
1210 {
1211   ParticleEmitter* emitter = (ParticleEmitter*)csEmitter;
1212   if(!emitter)
1213   {
1214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ParticleEmitter", 0);
1215     return 0;
1216   }
1217   {
1218     try
1219     {
1220       return int(emitter->GetRenderer().GetBlendingMode());
1221     }
1222     CALL_CATCH_EXCEPTION(0);
1223   }
1224 }
1225
1226 // PARTICLE
1227
1228 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Particle_New_SWIG_0(void* particleList, float lifetime, uint32_t* outIndex)
1229 {
1230   ParticleList* list = (ParticleList*)particleList;
1231   Particle      result;
1232   {
1233     try
1234     {
1235       result = list->NewParticle(lifetime);
1236     }
1237     CALL_CATCH_EXCEPTION(0);
1238   }
1239
1240   if(!result)
1241   {
1242     return false;
1243   }
1244   // result is body/handle but C# side provides only a view on particle so we return index in the stream
1245   // C# side should bind list and index to access particle data
1246   *outIndex = result.GetIndex();
1247   return true;
1248 }
1249
1250 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Particle_SWIG_0()
1251 {
1252   Particle* result = 0;
1253
1254   {
1255     try
1256     {
1257       result = (Particle*)new Particle();
1258     }
1259     CALL_CATCH_EXCEPTION(0);
1260   }
1261
1262   return (void*)result;
1263 }
1264
1265 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Particle_SWIG_1(void* csParticle)
1266 {
1267   Particle* particle = (Particle*)csParticle;
1268   Particle* result   = 0;
1269
1270   if(!particle)
1271   {
1272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Particle const & type is null", 0);
1273     return 0;
1274   }
1275   {
1276     try
1277     {
1278       result = (Particle*)new Particle((Particle const&)*particle);
1279     }
1280     CALL_CATCH_EXCEPTION(0);
1281   }
1282
1283   return (void*)result;
1284 }
1285
1286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Particle(void* csParticle)
1287 {
1288   Particle* particle = (Particle*)csParticle;
1289   {
1290     try
1291     {
1292       delete particle;
1293     }
1294     CALL_CATCH_EXCEPTION();
1295   }
1296 }
1297
1298 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Particle_Assign(void* csDestination, void* csSource)
1299 {
1300   Particle* destination = (Particle*)csDestination;
1301   Particle* source      = (Particle*)csSource;
1302   Particle* result      = 0;
1303
1304   if(!source)
1305   {
1306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Particle const & type is null", 0);
1307     return 0;
1308   }
1309   {
1310     try
1311     {
1312       result = (Particle*)&(destination)->operator=((Particle const&)*source);
1313     }
1314     CALL_CATCH_EXCEPTION(0);
1315   }
1316
1317   return (void*)result;
1318 }
1319
1320 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Particle_DownCast(void* csHandle)
1321 {
1322   Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle;
1323   Particle          result;
1324
1325   if(!handle)
1326   {
1327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Particle", 0);
1328     return 0;
1329   }
1330   {
1331     try
1332     {
1333       result = Particle::DownCast(*handle);
1334     }
1335     CALL_CATCH_EXCEPTION(0);
1336   }
1337
1338   return new Particle((const Particle&)result);
1339 }
1340
1341 #ifdef __cplusplus
1342 }
1343 #endif