From: Eunki Hong <eunkiki.hong@samsung.com>
Date: Tue, 4 Jul 2023 13:29:50 +0000 (+0900)
Subject: Bind MotionData / MotionIndex / MotionValue
X-Git-Tag: dali_2.2.34~2
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F88%2F295288%2F4;p=platform%2Fcore%2Fuifw%2Fdali-csharp-binder.git

Bind MotionData / MotionIndex / MotionValue

Bind public API for MotionData features.

Change-Id: I5a1cc1d08cde40c3ecb6ca59cc99605e145e1b32
Signed-off-by: Eunki Hong <eunkiki.hong@samsung.com>
---

diff --git a/dali-csharp-binder/file.list b/dali-csharp-binder/file.list
index cad1abc..019d7fc 100755
--- a/dali-csharp-binder/file.list
+++ b/dali-csharp-binder/file.list
@@ -99,9 +99,12 @@ SET( dali_csharp_binder_tizen_wearable_src_files
 SET( dali_csharp_binder_scene3d_src_files
   ${dali_csharp_binder_dir}/src/light-wrap.cpp
   ${dali_csharp_binder_dir}/src/material-wrap.cpp
-  ${dali_csharp_binder_dir}/src/model-primitive-wrap.cpp
   ${dali_csharp_binder_dir}/src/model-node-wrap.cpp
+  ${dali_csharp_binder_dir}/src/model-primitive-wrap.cpp
   ${dali_csharp_binder_dir}/src/model-wrap.cpp
+  ${dali_csharp_binder_dir}/src/motion-data-wrap.cpp
+  ${dali_csharp_binder_dir}/src/motion-index-wrap.cpp
+  ${dali_csharp_binder_dir}/src/motion-value-wrap.cpp
   ${dali_csharp_binder_dir}/src/scene-view-wrap.cpp
 )
 
diff --git a/dali-csharp-binder/src/model-wrap.cpp b/dali-csharp-binder/src/model-wrap.cpp
index 28adbf6..b3b254a 100644
--- a/dali-csharp-binder/src/model-wrap.cpp
+++ b/dali-csharp-binder/src/model-wrap.cpp
@@ -19,6 +19,7 @@
 #include <dali-scene3d/public-api/controls/model/model.h>
 #include <dali-scene3d/public-api/loader/bvh-loader.h>
 #include <dali-scene3d/public-api/loader/facial-animation-loader.h>
+#include <dali-scene3d/public-api/model-motion/motion-data.h>
 #include <dali/devel-api/animation/key-frames-devel.h>
 
 // INTERNAL INCLUDES
@@ -484,6 +485,55 @@ SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_FindChildModelNodeByName(void* cs
   return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result);
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GenerateMotionDataAnimation(void* csModel, void* csMotionData)
+{
+  Dali::Scene3D::Model*      model      = (Dali::Scene3D::Model*)csModel;
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+  Dali::Animation            result;
+
+  if(!model)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0);
+    return nullptr;
+  }
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return nullptr;
+  }
+
+  try
+  {
+    result = model->GenerateMotionDataAnimation(*motionData);
+  }
+  CALL_CATCH_EXCEPTION(nullptr);
+
+  return new Dali::Animation((const Dali::Animation&)result);
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_SetMotionData(void* csModel, void* csMotionData)
+{
+  Dali::Scene3D::Model*      model      = (Dali::Scene3D::Model*)csModel;
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+
+  if(!model)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0);
+    return;
+  }
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return;
+  }
+
+  try
+  {
+    model->SetMotionData(*motionData);
+  }
+  CALL_CATCH_EXCEPTION();
+}
+
 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_LoadBvhAnimation_1(void* csModel, char* csFileName, void* csScale, bool csUseRootNodeTranslate)
 {
   Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel;
diff --git a/dali-csharp-binder/src/motion-data-wrap.cpp b/dali-csharp-binder/src/motion-data-wrap.cpp
new file mode 100644
index 0000000..9b4b68f
--- /dev/null
+++ b/dali-csharp-binder/src/motion-data-wrap.cpp
@@ -0,0 +1,426 @@
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali-scene3d/public-api/model-motion/motion-data.h>
+#include <dali-scene3d/public-api/model-motion/motion-index/motion-index.h>
+#include <dali-scene3d/public-api/model-motion/motion-value.h>
+
+// INTERNAL INCLUDES
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_New_SWIG_0()
+{
+  Dali::Scene3D::MotionData result;
+
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionData::New();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionData((const Dali::Scene3D::MotionData&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_New_SWIG_1(float durationSeconds)
+{
+  Dali::Scene3D::MotionData result;
+
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionData::New(durationSeconds);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionData((const Dali::Scene3D::MotionData&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionData_SWIG_0()
+{
+  Dali::Scene3D::MotionData* result = 0;
+
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionData*)new Dali::Scene3D::MotionData();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionData_SWIG_1(void* csMotionData)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+  Dali::Scene3D::MotionData* result     = 0;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionData const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionData*)new Dali::Scene3D::MotionData((Dali::Scene3D::MotionData const&)*motionData);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionData(void* csMotionData)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+  {
+    try
+    {
+      delete motionData;
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_Assign(void* csDestination, void* csSource)
+{
+  Dali::Scene3D::MotionData* destination = (Dali::Scene3D::MotionData*)csDestination;
+  Dali::Scene3D::MotionData* source      = (Dali::Scene3D::MotionData*)csSource;
+  Dali::Scene3D::MotionData* result      = 0;
+
+  if(!source)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionData const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionData*)&(destination)->operator=((Dali::Scene3D::MotionData const&)*source);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_DownCast(void* csHandle)
+{
+  Dali::BaseHandle*         handle = (Dali::BaseHandle*)csHandle;
+  Dali::Scene3D::MotionData result;
+
+  if(!handle)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionData::DownCast(*handle);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionData((const Dali::Scene3D::MotionData&)result);
+}
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MotionData_GetMotionCount(void* csMotionData)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+  unsigned int               result;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = static_cast<unsigned int>(motionData->GetMotionCount());
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_GetIndex(void* csMotionData, unsigned int index)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+  Dali::Scene3D::MotionIndex result;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = motionData->GetIndex(static_cast<uint32_t>(index));
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionIndex((const Dali::Scene3D::MotionIndex&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_GetValue(void* csMotionData, unsigned int index)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+  Dali::Scene3D::MotionValue result;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = motionData->GetValue(static_cast<uint32_t>(index));
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result);
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_Add(void* csMotionData, void* csMotionIndex, void* csMotionValue)
+{
+  Dali::Scene3D::MotionData*  motionData  = (Dali::Scene3D::MotionData*)csMotionData;
+  Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex;
+  Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return;
+  }
+  if(!motionIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionIndex", 0);
+    return;
+  }
+  if(!motionValue)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0);
+    return;
+  }
+
+  {
+    try
+    {
+      motionData->Add(*motionIndex, *motionValue);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_Clear(void* csMotionData)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return;
+  }
+
+  {
+    try
+    {
+      motionData->Clear();
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_SetDuration(void* csMotionData, float durationSeconds)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return;
+  }
+
+  {
+    try
+    {
+      motionData->SetDuration(durationSeconds);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MotionData_GetDuration(void* csMotionData)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+  float                      result;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return 0.0f;
+  }
+
+  {
+    try
+    {
+      result = motionData->GetDuration();
+    }
+    CALL_CATCH_EXCEPTION(0.0f);
+  }
+
+  return result;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadBvh(void* csMotionData, char* csFileName, void* csScale, bool csSynchronousLoad)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return;
+  }
+  if(!csFileName)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for filename", 0);
+    return;
+  }
+
+  Dali::Vector3 scale = Dali::Vector3::ONE;
+  // csScale is option.
+  if(csScale != nullptr)
+  {
+    scale = Dali::Vector3(*static_cast<const Dali::Vector3*>(csScale));
+  }
+
+  std::string filename(csFileName);
+  {
+    try
+    {
+      motionData->LoadBvh(filename, scale, csSynchronousLoad);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadBvhFromBuffer(void* csMotionData, char* csBuffer, int csBufferLength, void* csScale, bool csSynchronousLoad)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return;
+  }
+  if(!csBuffer)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for buffer", 0);
+    return;
+  }
+
+  Dali::Vector3 scale = Dali::Vector3::ONE;
+  // csScale is option.
+  if(csScale != nullptr)
+  {
+    scale = Dali::Vector3(*static_cast<const Dali::Vector3*>(csScale));
+  }
+
+  const uint8_t* rawBuffer = reinterpret_cast<const uint8_t*>(csBuffer);
+  {
+    try
+    {
+      motionData->LoadBvhFromBuffer(rawBuffer, csBufferLength, scale, csSynchronousLoad);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadFacialAnimation(void* csMotionData, char* csFileName, bool csSynchronousLoad)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return;
+  }
+  if(!csFileName)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for filename", 0);
+    return;
+  }
+
+  std::string filename(csFileName);
+  {
+    try
+    {
+      motionData->LoadFacialAnimation(filename, csSynchronousLoad);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadFacialAnimationFromBuffer(void* csMotionData, char* csBuffer, int csBufferLength, bool csSynchronousLoad)
+{
+  Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData;
+
+  if(!motionData)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0);
+    return;
+  }
+  if(!csBuffer)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for buffer", 0);
+    return;
+  }
+
+  const uint8_t* rawBuffer = reinterpret_cast<const uint8_t*>(csBuffer);
+  {
+    try
+    {
+      motionData->LoadFacialAnimationFromBuffer(rawBuffer, csBufferLength, csSynchronousLoad);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+// Signals
+GENERATE_SIGNAL(Dali::Scene3D::MotionData*, void(*)(Dali::Scene3D::MotionData), Dali_MotionData, LoadCompletedSignal);
+// CSharp_Dali_MotionData_LoadCompletedSignal_Connect
+// CSharp_Dali_MotionData_LoadCompletedSignal_Disconnect
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/dali-csharp-binder/src/motion-index-wrap.cpp b/dali-csharp-binder/src/motion-index-wrap.cpp
new file mode 100644
index 0000000..5ec61bc
--- /dev/null
+++ b/dali-csharp-binder/src/motion-index-wrap.cpp
@@ -0,0 +1,720 @@
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali-scene3d/public-api/model-motion/motion-index/blend-shape-index.h>
+#include <dali-scene3d/public-api/model-motion/motion-index/motion-index.h>
+#include <dali-scene3d/public-api/model-motion/motion-index/motion-property-index.h>
+#include <dali-scene3d/public-api/model-motion/motion-index/motion-transform-index.h>
+
+// INTERNAL INCLUDES
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// MotionIndex
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionIndex_SWIG_0()
+{
+  Dali::Scene3D::MotionIndex* result = 0;
+
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionIndex*)new Dali::Scene3D::MotionIndex();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionIndex_SWIG_1(void* csMotionIndex)
+{
+  Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex;
+  Dali::Scene3D::MotionIndex* result     = 0;
+
+  if(!motionIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionIndex*)new Dali::Scene3D::MotionIndex((Dali::Scene3D::MotionIndex const&)*motionIndex);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionIndex(void* csMotionIndex)
+{
+  Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex;
+  {
+    try
+    {
+      delete motionIndex;
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionIndex_Assign(void* csDestination, void* csSource)
+{
+  Dali::Scene3D::MotionIndex* destination = (Dali::Scene3D::MotionIndex*)csDestination;
+  Dali::Scene3D::MotionIndex* source      = (Dali::Scene3D::MotionIndex*)csSource;
+  Dali::Scene3D::MotionIndex* result      = 0;
+
+  if(!source)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionIndex*)&(destination)->operator=((Dali::Scene3D::MotionIndex const&)*source);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionIndex_DownCast(void* csHandle)
+{
+  Dali::BaseHandle*          handle = (Dali::BaseHandle*)csHandle;
+  Dali::Scene3D::MotionIndex result;
+
+  if(!handle)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionIndex::DownCast(*handle);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionIndex((const Dali::Scene3D::MotionIndex&)result);
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionIndex_SetModelNodeId(void* csMotionIndex, void* csPropertyKey)
+{
+  Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex;
+  Dali::Property::Key*        propertyKey = (Dali::Property::Key*)csPropertyKey;
+
+  if(!motionIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionIndex", 0);
+    return;
+  }
+  if(!propertyKey)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
+    return;
+  }
+  {
+    try
+    {
+      motionIndex->SetModelNodeId(*propertyKey);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionIndex_GetModelNodeId(void* csMotionIndex)
+{
+  Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex;
+  Dali::Property::Key         result      = Dali::Property::INVALID_KEY;
+
+  if(!motionIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionIndex", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = motionIndex->GetModelNodeId();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Property::Key((Dali::Property::Key const &)result);
+}
+
+// BlendShapeIndex
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_New_SWIG_0()
+{
+  Dali::Scene3D::BlendShapeIndex result;
+
+  {
+    try
+    {
+      result = Dali::Scene3D::BlendShapeIndex::New();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_New_SWIG_1(void* csBlendShapePropertyKey)
+{
+  Dali::Property::Key*           blendShapePropertyKey = (Dali::Property::Key*)csBlendShapePropertyKey;
+  Dali::Scene3D::BlendShapeIndex result;
+
+  if(!blendShapePropertyKey)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::BlendShapeIndex::New(*blendShapePropertyKey);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_New_SWIG_2(void* csModelNodePropertKey, void* csBlendShapePropertyKey)
+{
+  Dali::Property::Key*           modelNodePropertyKey  = (Dali::Property::Key*)csModelNodePropertKey;
+  Dali::Property::Key*           blendShapePropertyKey = (Dali::Property::Key*)csBlendShapePropertyKey;
+  Dali::Scene3D::BlendShapeIndex result;
+
+  if(!modelNodePropertyKey)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "modelNodePropertyKey Dali::Property::Key const & type is null", 0);
+    return 0;
+  }
+  if(!blendShapePropertyKey)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "blendShapePropertyKey Dali::Property::Key const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::BlendShapeIndex::New(*modelNodePropertyKey, *blendShapePropertyKey);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_BlendShapeIndex_SWIG_0()
+{
+  Dali::Scene3D::BlendShapeIndex* result = 0;
+
+  {
+    try
+    {
+      result = (Dali::Scene3D::BlendShapeIndex*)new Dali::Scene3D::BlendShapeIndex();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_BlendShapeIndex_SWIG_1(void* csBlendShapeIndex)
+{
+  Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex;
+  Dali::Scene3D::BlendShapeIndex* result     = 0;
+
+  if(!blendShapeIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::BlendShapeIndex*)new Dali::Scene3D::BlendShapeIndex((Dali::Scene3D::BlendShapeIndex const&)*blendShapeIndex);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BlendShapeIndex(void* csBlendShapeIndex)
+{
+  Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex;
+  {
+    try
+    {
+      delete blendShapeIndex;
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_Assign(void* csDestination, void* csSource)
+{
+  Dali::Scene3D::BlendShapeIndex* destination = (Dali::Scene3D::BlendShapeIndex*)csDestination;
+  Dali::Scene3D::BlendShapeIndex* source      = (Dali::Scene3D::BlendShapeIndex*)csSource;
+  Dali::Scene3D::BlendShapeIndex* result      = 0;
+
+  if(!source)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::BlendShapeIndex*)&(destination)->operator=((Dali::Scene3D::BlendShapeIndex const&)*source);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_DownCast(void* csHandle)
+{
+  Dali::BaseHandle*              handle = (Dali::BaseHandle*)csHandle;
+  Dali::Scene3D::BlendShapeIndex result;
+
+  if(!handle)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::BlendShapeIndex::DownCast(*handle);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result);
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BlendShapeIndex_SetBlendShapeId(void* csBlendShapeIndex, void* csBlendShapePropertyKey)
+{
+  Dali::Scene3D::BlendShapeIndex* blendShapeIndex       = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex;
+  Dali::Property::Key*            blendShapePropertyKey = (Dali::Property::Key*)csBlendShapePropertyKey;
+
+  if(!blendShapeIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0);
+    return;
+  }
+  if(!blendShapePropertyKey)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
+    return;
+  }
+  {
+    try
+    {
+      blendShapeIndex->SetBlendShapeId(*blendShapePropertyKey);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_GetBlendShapeId(void* csBlendShapeIndex)
+{
+  Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex;
+  Dali::Property::Key             result          = Dali::Property::INVALID_KEY;
+
+  if(!blendShapeIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = blendShapeIndex->GetBlendShapeId();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Property::Key((Dali::Property::Key const &)result);
+}
+
+// MotionPropertyIndex
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_New_SWIG_0()
+{
+  Dali::Scene3D::MotionPropertyIndex result;
+
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionPropertyIndex::New();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionPropertyIndex((const Dali::Scene3D::MotionPropertyIndex&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_New_SWIG_1(void* csModelNodePropertKey, void* csPropertyKey)
+{
+  Dali::Property::Key*               modelNodePropertyKey  = (Dali::Property::Key*)csModelNodePropertKey;
+  Dali::Property::Key*               propertyKey           = (Dali::Property::Key*)csPropertyKey;
+  Dali::Scene3D::MotionPropertyIndex result;
+
+  if(!modelNodePropertyKey)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "modelNodePropertyKey Dali::Property::Key const & type is null", 0);
+    return 0;
+  }
+  if(!propertyKey)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "propertyKey Dali::Property::Key const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionPropertyIndex::New(*modelNodePropertyKey, *propertyKey);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionPropertyIndex((const Dali::Scene3D::MotionPropertyIndex&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionPropertyIndex_SWIG_0()
+{
+  Dali::Scene3D::MotionPropertyIndex* result = 0;
+
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionPropertyIndex*)new Dali::Scene3D::MotionPropertyIndex();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionPropertyIndex_SWIG_1(void* csMotionPropertyIndex)
+{
+  Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex;
+  Dali::Scene3D::MotionPropertyIndex* result              = 0;
+
+  if(!motionPropertyIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionPropertyIndex*)new Dali::Scene3D::MotionPropertyIndex((Dali::Scene3D::MotionPropertyIndex const&)*motionPropertyIndex);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionPropertyIndex(void* csMotionPropertyIndex)
+{
+  Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex;
+  {
+    try
+    {
+      delete motionPropertyIndex;
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_Assign(void* csDestination, void* csSource)
+{
+  Dali::Scene3D::MotionPropertyIndex* destination = (Dali::Scene3D::MotionPropertyIndex*)csDestination;
+  Dali::Scene3D::MotionPropertyIndex* source      = (Dali::Scene3D::MotionPropertyIndex*)csSource;
+  Dali::Scene3D::MotionPropertyIndex* result      = 0;
+
+  if(!source)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionPropertyIndex*)&(destination)->operator=((Dali::Scene3D::MotionPropertyIndex const&)*source);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_DownCast(void* csHandle)
+{
+  Dali::BaseHandle*                  handle = (Dali::BaseHandle*)csHandle;
+  Dali::Scene3D::MotionPropertyIndex result;
+
+  if(!handle)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionPropertyIndex::DownCast(*handle);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionPropertyIndex((const Dali::Scene3D::MotionPropertyIndex&)result);
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_SetPropertyId(void* csMotionPropertyIndex, void* csPropertyKey)
+{
+  Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex;
+  Dali::Property::Key*                propertyKey         = (Dali::Property::Key*)csPropertyKey;
+
+  if(!motionPropertyIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0);
+    return;
+  }
+  if(!propertyKey)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
+    return;
+  }
+  {
+    try
+    {
+      motionPropertyIndex->SetPropertyId(*propertyKey);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_GetPropertyId(void* csMotionPropertyIndex)
+{
+  Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex;
+  Dali::Property::Key                 result              = Dali::Property::INVALID_KEY;
+
+  if(!motionPropertyIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = motionPropertyIndex->GetPropertyId();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Property::Key((Dali::Property::Key const &)result);
+}
+
+// MotionTransformIndex
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_New_SWIG_0()
+{
+  Dali::Scene3D::MotionTransformIndex result;
+
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionTransformIndex::New();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionTransformIndex((const Dali::Scene3D::MotionTransformIndex&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_New_SWIG_1(void* csModelNodePropertKey, int csTransformType)
+{
+  Dali::Property::Key*                modelNodePropertyKey  = (Dali::Property::Key*)csModelNodePropertKey;
+  Dali::Scene3D::MotionTransformIndex result;
+
+  if(!modelNodePropertyKey)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "modelNodePropertyKey Dali::Property::Key const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionTransformIndex::New(*modelNodePropertyKey, static_cast<Dali::Scene3D::MotionTransformIndex::TransformType>(csTransformType));
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionTransformIndex((const Dali::Scene3D::MotionTransformIndex&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionTransformIndex_SWIG_0()
+{
+  Dali::Scene3D::MotionTransformIndex* result = 0;
+
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionTransformIndex*)new Dali::Scene3D::MotionTransformIndex();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionTransformIndex_SWIG_1(void* csMotionTransformIndex)
+{
+  Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex;
+  Dali::Scene3D::MotionTransformIndex* result              = 0;
+
+  if(!motionTransformIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionTransformIndex*)new Dali::Scene3D::MotionTransformIndex((Dali::Scene3D::MotionTransformIndex const&)*motionTransformIndex);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionTransformIndex(void* csMotionTransformIndex)
+{
+  Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex;
+  {
+    try
+    {
+      delete motionTransformIndex;
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_Assign(void* csDestination, void* csSource)
+{
+  Dali::Scene3D::MotionTransformIndex* destination = (Dali::Scene3D::MotionTransformIndex*)csDestination;
+  Dali::Scene3D::MotionTransformIndex* source      = (Dali::Scene3D::MotionTransformIndex*)csSource;
+  Dali::Scene3D::MotionTransformIndex* result      = 0;
+
+  if(!source)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionTransformIndex*)&(destination)->operator=((Dali::Scene3D::MotionTransformIndex const&)*source);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_DownCast(void* csHandle)
+{
+  Dali::BaseHandle*                   handle = (Dali::BaseHandle*)csHandle;
+  Dali::Scene3D::MotionTransformIndex result;
+
+  if(!handle)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionTransformIndex::DownCast(*handle);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionTransformIndex((const Dali::Scene3D::MotionTransformIndex&)result);
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionTransformIndex_SetTransformType(void* csMotionTransformIndex, int csTransformType)
+{
+  Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex;
+
+  if(!motionTransformIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0);
+    return;
+  }
+  {
+    try
+    {
+      motionTransformIndex->SetTransformType(static_cast<Dali::Scene3D::MotionTransformIndex::TransformType>(csTransformType));
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MotionTransformIndex_GetTransformType(void* csMotionTransformIndex)
+{
+  Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex;
+  int                                  result;
+
+  if(!motionTransformIndex)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = static_cast<int>(motionTransformIndex->GetTransformType());
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return result;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/dali-csharp-binder/src/motion-value-wrap.cpp b/dali-csharp-binder/src/motion-value-wrap.cpp
new file mode 100644
index 0000000..a52c91f
--- /dev/null
+++ b/dali-csharp-binder/src/motion-value-wrap.cpp
@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/animation/key-frames.h>
+#include <dali/public-api/object/property-value.h>
+#include <dali-scene3d/public-api/model-motion/motion-value.h>
+
+// INTERNAL INCLUDES
+#include "common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_New_SWIG_0()
+{
+  Dali::Scene3D::MotionValue result;
+
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionValue::New();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_New_SWIG_1(void* csPropertyValue)
+{
+  Dali::Property::Value*     propertyValue = (Dali::Property::Value*)csPropertyValue;
+  Dali::Scene3D::MotionValue result;
+
+  if(!propertyValue)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionValue::New(*propertyValue);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_New_SWIG_2(void* csKeyFrames)
+{
+  Dali::KeyFrames*           keyFrames = (Dali::KeyFrames*)csKeyFrames;
+  Dali::Scene3D::MotionValue result;
+
+  if(!keyFrames)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionValue::New(*keyFrames);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionValue_SWIG_0()
+{
+  Dali::Scene3D::MotionValue* result = 0;
+
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionValue*)new Dali::Scene3D::MotionValue();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionValue_SWIG_1(void* csMotionValue)
+{
+  Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue;
+  Dali::Scene3D::MotionValue* result     = 0;
+
+  if(!motionValue)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionValue const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionValue*)new Dali::Scene3D::MotionValue((Dali::Scene3D::MotionValue const&)*motionValue);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionValue(void* csMotionValue)
+{
+  Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue;
+  {
+    try
+    {
+      delete motionValue;
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_Assign(void* csDestination, void* csSource)
+{
+  Dali::Scene3D::MotionValue* destination = (Dali::Scene3D::MotionValue*)csDestination;
+  Dali::Scene3D::MotionValue* source      = (Dali::Scene3D::MotionValue*)csSource;
+  Dali::Scene3D::MotionValue* result      = 0;
+
+  if(!source)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionValue const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = (Dali::Scene3D::MotionValue*)&(destination)->operator=((Dali::Scene3D::MotionValue const&)*source);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (void*)result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_DownCast(void* csHandle)
+{
+  Dali::BaseHandle*          handle = (Dali::BaseHandle*)csHandle;
+  Dali::Scene3D::MotionValue result;
+
+  if(!handle)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Scene3D::MotionValue::DownCast(*handle);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result);
+}
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MotionValue_GetValueType(void* csMotionValue)
+{
+  Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue;
+  int                         result;
+
+  if(!motionValue)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = static_cast<int>(motionValue->GetValueType());
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return result;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionValue_SetValue_PropertyValue(void* csMotionValue, void* csPropertyValue)
+{
+  Dali::Scene3D::MotionValue* motionValue   = (Dali::Scene3D::MotionValue*)csMotionValue;
+  Dali::Property::Value*      propertyValue = (Dali::Property::Value*)csPropertyValue;
+
+  if(!motionValue)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0);
+    return;
+  }
+  if(!propertyValue)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
+    return;
+  }
+  {
+    try
+    {
+      motionValue->SetValue(*propertyValue);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionValue_SetValue_KeyFrames(void* csMotionValue, void* csKeyFrames)
+{
+  Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue;
+  Dali::KeyFrames*            keyFrames   = (Dali::KeyFrames*)csKeyFrames;
+
+  if(!motionValue)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0);
+    return;
+  }
+  if(!keyFrames)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
+    return;
+  }
+  {
+    try
+    {
+      motionValue->SetValue(*keyFrames);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionValue_Clear(void* csMotionValue)
+{
+  Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue;
+
+  if(!motionValue)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0);
+    return;
+  }
+  {
+    try
+    {
+      motionValue->Clear();
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_GetPropertyValue(void* csMotionValue)
+{
+  Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue;
+  Dali::Property::Value       result;
+
+  if(!motionValue)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = motionValue->GetPropertyValue();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::Property::Value((Dali::Property::Value const &)result);
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_GetKeyFrames(void* csMotionValue)
+{
+  Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue;
+  Dali::KeyFrames             result;
+
+  if(!motionValue)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = motionValue->GetKeyFrames();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::KeyFrames((Dali::KeyFrames const &)result);
+}
+
+#ifdef __cplusplus
+}
+#endif