text: #include "scripting/lua-bindings/auto/lua_cocos2dx_spine_auto.hpp"
  #include "editor-support/spine/spine-cocos2dx.h"
  #include "scripting/lua-bindings/manual/tolua_fix.h"
  #include "scripting/lua-bindings/manual/LuaBasicConversions.h"
  
  int lua_cocos2dx_spine_SkeletonRenderer_setTimeScale(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_setTimeScale'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 1) 
      {
          double arg0;
  
          ok &= luaval_to_number(tolua_S, 2,&arg0, "sp.SkeletonRenderer:setTimeScale");
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_setTimeScale'", nullptr);
              return 0;
          }
          cobj->setTimeScale(arg0);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:setTimeScale",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_setTimeScale'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_getDebugSlotsEnabled(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_getDebugSlotsEnabled'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_getDebugSlotsEnabled'", nullptr);
              return 0;
          }
          bool ret = cobj->getDebugSlotsEnabled();
          tolua_pushboolean(tolua_S,(bool)ret);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:getDebugSlotsEnabled",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_getDebugSlotsEnabled'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_setBonesToSetupPose(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_setBonesToSetupPose'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_setBonesToSetupPose'", nullptr);
              return 0;
          }
          cobj->setBonesToSetupPose();
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:setBonesToSetupPose",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_setBonesToSetupPose'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_initWithData(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_initWithData'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 1) 
      {
          spSkeletonData* arg0;
  
          #pragma warning NO CONVERSION TO NATIVE FOR spSkeletonData*
  		ok = false;
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_initWithData'", nullptr);
              return 0;
          }
          cobj->initWithData(arg0);
          lua_settop(tolua_S, 1);
          return 1;
      }
      if (argc == 2) 
      {
          spSkeletonData* arg0;
          bool arg1;
  
          #pragma warning NO CONVERSION TO NATIVE FOR spSkeletonData*
  		ok = false;
  
          ok &= luaval_to_boolean(tolua_S, 3,&arg1, "sp.SkeletonRenderer:initWithData");
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_initWithData'", nullptr);
              return 0;
          }
          cobj->initWithData(arg0, arg1);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:initWithData",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_initWithData'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_setDebugSlotsEnabled(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_setDebugSlotsEnabled'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 1) 
      {
          bool arg0;
  
          ok &= luaval_to_boolean(tolua_S, 2,&arg0, "sp.SkeletonRenderer:setDebugSlotsEnabled");
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_setDebugSlotsEnabled'", nullptr);
              return 0;
          }
          cobj->setDebugSlotsEnabled(arg0);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:setDebugSlotsEnabled",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_setDebugSlotsEnabled'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_setSlotsToSetupPose(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_setSlotsToSetupPose'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_setSlotsToSetupPose'", nullptr);
              return 0;
          }
          cobj->setSlotsToSetupPose();
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:setSlotsToSetupPose",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_setSlotsToSetupPose'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_setToSetupPose(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_setToSetupPose'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_setToSetupPose'", nullptr);
              return 0;
          }
          cobj->setToSetupPose();
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:setToSetupPose",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_setToSetupPose'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_getBlendFunc(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_getBlendFunc'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_getBlendFunc'", nullptr);
              return 0;
          }
          const cocos2d::BlendFunc& ret = cobj->getBlendFunc();
          blendfunc_to_luaval(tolua_S, ret);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:getBlendFunc",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_getBlendFunc'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_initialize(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_initialize'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_initialize'", nullptr);
              return 0;
          }
          cobj->initialize();
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:initialize",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_initialize'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_setDebugBonesEnabled(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_setDebugBonesEnabled'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 1) 
      {
          bool arg0;
  
          ok &= luaval_to_boolean(tolua_S, 2,&arg0, "sp.SkeletonRenderer:setDebugBonesEnabled");
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_setDebugBonesEnabled'", nullptr);
              return 0;
          }
          cobj->setDebugBonesEnabled(arg0);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:setDebugBonesEnabled",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_setDebugBonesEnabled'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_getDebugBonesEnabled(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_getDebugBonesEnabled'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_getDebugBonesEnabled'", nullptr);
              return 0;
          }
          bool ret = cobj->getDebugBonesEnabled();
          tolua_pushboolean(tolua_S,(bool)ret);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:getDebugBonesEnabled",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_getDebugBonesEnabled'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_getTimeScale(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_getTimeScale'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_getTimeScale'", nullptr);
              return 0;
          }
          double ret = cobj->getTimeScale();
          tolua_pushnumber(tolua_S,(lua_Number)ret);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:getTimeScale",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_getTimeScale'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_initWithFile(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  #if COCOS2D_DEBUG >= 1
      if (!cobj)
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_initWithFile'", nullptr);
          return 0;
      }
  #endif
      argc = lua_gettop(tolua_S)-1;
      do{
          if (argc == 2) {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:initWithFile");
  
              if (!ok) { break; }
              std::string arg1;
              ok &= luaval_to_std_string(tolua_S, 3,&arg1, "sp.SkeletonRenderer:initWithFile");
  
              if (!ok) { break; }
              cobj->initWithFile(arg0, arg1);
              lua_settop(tolua_S, 1);
              return 1;
          }
      }while(0);
      ok  = true;
      do{
          if (argc == 3) {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:initWithFile");
  
              if (!ok) { break; }
              std::string arg1;
              ok &= luaval_to_std_string(tolua_S, 3,&arg1, "sp.SkeletonRenderer:initWithFile");
  
              if (!ok) { break; }
              double arg2;
              ok &= luaval_to_number(tolua_S, 4,&arg2, "sp.SkeletonRenderer:initWithFile");
  
              if (!ok) { break; }
              cobj->initWithFile(arg0, arg1, arg2);
              lua_settop(tolua_S, 1);
              return 1;
          }
      }while(0);
      ok  = true;
      do{
          if (argc == 2) {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:initWithFile");
  
              if (!ok) { break; }
              spAtlas* arg1;
              #pragma warning NO CONVERSION TO NATIVE FOR spAtlas*
  		ok = false;
  
              if (!ok) { break; }
              cobj->initWithFile(arg0, arg1);
              lua_settop(tolua_S, 1);
              return 1;
          }
      }while(0);
      ok  = true;
      do{
          if (argc == 3) {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:initWithFile");
  
              if (!ok) { break; }
              spAtlas* arg1;
              #pragma warning NO CONVERSION TO NATIVE FOR spAtlas*
  		ok = false;
  
              if (!ok) { break; }
              double arg2;
              ok &= luaval_to_number(tolua_S, 4,&arg2, "sp.SkeletonRenderer:initWithFile");
  
              if (!ok) { break; }
              cobj->initWithFile(arg0, arg1, arg2);
              lua_settop(tolua_S, 1);
              return 1;
          }
      }while(0);
      ok  = true;
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n",  "sp.SkeletonRenderer:initWithFile",argc, 2);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_initWithFile'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_setBlendFunc(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_setBlendFunc'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 1) 
      {
          cocos2d::BlendFunc arg0;
  
          ok &= luaval_to_blendfunc(tolua_S, 2, &arg0, "sp.SkeletonRenderer:setBlendFunc");
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_setBlendFunc'", nullptr);
              return 0;
          }
          cobj->setBlendFunc(arg0);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:setBlendFunc",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_setBlendFunc'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_setSkin(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  #if COCOS2D_DEBUG >= 1
      if (!cobj)
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_setSkin'", nullptr);
          return 0;
      }
  #endif
      argc = lua_gettop(tolua_S)-1;
      do{
          if (argc == 1) {
              const char* arg0;
              std::string arg0_tmp; ok &= luaval_to_std_string(tolua_S, 2, &arg0_tmp, "sp.SkeletonRenderer:setSkin"); arg0 = arg0_tmp.c_str();
  
              if (!ok) { break; }
              bool ret = cobj->setSkin(arg0);
              tolua_pushboolean(tolua_S,(bool)ret);
              return 1;
          }
      }while(0);
      ok  = true;
      do{
          if (argc == 1) {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:setSkin");
  
              if (!ok) { break; }
              bool ret = cobj->setSkin(arg0);
              tolua_pushboolean(tolua_S,(bool)ret);
              return 1;
          }
      }while(0);
      ok  = true;
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n",  "sp.SkeletonRenderer:setSkin",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_setSkin'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_getSkeleton(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonRenderer*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonRenderer_getSkeleton'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_getSkeleton'", nullptr);
              return 0;
          }
          spSkeleton* ret = cobj->getSkeleton();
          #pragma warning NO CONVERSION FROM NATIVE FOR spSkeleton*;
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonRenderer:getSkeleton",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_getSkeleton'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_createWithFile(lua_State* tolua_S)
  {
      int argc = 0;
      bool ok  = true;
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertable(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      argc = lua_gettop(tolua_S)-1;
  
      do 
      {
          if (argc == 2)
          {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:createWithFile");
              if (!ok) { break; }
              std::string arg1;
              ok &= luaval_to_std_string(tolua_S, 3,&arg1, "sp.SkeletonRenderer:createWithFile");
              if (!ok) { break; }
              spine::SkeletonRenderer* ret = spine::SkeletonRenderer::createWithFile(arg0, arg1);
              object_to_luaval<spine::SkeletonRenderer>(tolua_S, "sp.SkeletonRenderer",(spine::SkeletonRenderer*)ret);
              return 1;
          }
      } while (0);
      ok  = true;
      do 
      {
          if (argc == 3)
          {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:createWithFile");
              if (!ok) { break; }
              std::string arg1;
              ok &= luaval_to_std_string(tolua_S, 3,&arg1, "sp.SkeletonRenderer:createWithFile");
              if (!ok) { break; }
              double arg2;
              ok &= luaval_to_number(tolua_S, 4,&arg2, "sp.SkeletonRenderer:createWithFile");
              if (!ok) { break; }
              spine::SkeletonRenderer* ret = spine::SkeletonRenderer::createWithFile(arg0, arg1, arg2);
              object_to_luaval<spine::SkeletonRenderer>(tolua_S, "sp.SkeletonRenderer",(spine::SkeletonRenderer*)ret);
              return 1;
          }
      } while (0);
      ok  = true;
      do 
      {
          if (argc == 2)
          {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:createWithFile");
              if (!ok) { break; }
              spAtlas* arg1;
              #pragma warning NO CONVERSION TO NATIVE FOR spAtlas*
  		ok = false;
              if (!ok) { break; }
              spine::SkeletonRenderer* ret = spine::SkeletonRenderer::createWithFile(arg0, arg1);
              object_to_luaval<spine::SkeletonRenderer>(tolua_S, "sp.SkeletonRenderer",(spine::SkeletonRenderer*)ret);
              return 1;
          }
      } while (0);
      ok  = true;
      do 
      {
          if (argc == 3)
          {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:createWithFile");
              if (!ok) { break; }
              spAtlas* arg1;
              #pragma warning NO CONVERSION TO NATIVE FOR spAtlas*
  		ok = false;
              if (!ok) { break; }
              double arg2;
              ok &= luaval_to_number(tolua_S, 4,&arg2, "sp.SkeletonRenderer:createWithFile");
              if (!ok) { break; }
              spine::SkeletonRenderer* ret = spine::SkeletonRenderer::createWithFile(arg0, arg1, arg2);
              object_to_luaval<spine::SkeletonRenderer>(tolua_S, "sp.SkeletonRenderer",(spine::SkeletonRenderer*)ret);
              return 1;
          }
      } while (0);
      ok  = true;
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d", "sp.SkeletonRenderer:createWithFile",argc, 2);
      return 0;
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_createWithFile'.",&tolua_err);
  #endif
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_create(lua_State* tolua_S)
  {
      int argc = 0;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertable(tolua_S,1,"sp.SkeletonRenderer",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      argc = lua_gettop(tolua_S) - 1;
  
      if (argc == 0)
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonRenderer_create'", nullptr);
              return 0;
          }
          spine::SkeletonRenderer* ret = spine::SkeletonRenderer::create();
          object_to_luaval<spine::SkeletonRenderer>(tolua_S, "sp.SkeletonRenderer",(spine::SkeletonRenderer*)ret);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "sp.SkeletonRenderer:create",argc, 0);
      return 0;
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_create'.",&tolua_err);
  #endif
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonRenderer_constructor(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonRenderer* cobj = nullptr;
      bool ok  = true;
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      do{
          if (argc == 1) {
              spSkeletonData* arg0;
              #pragma warning NO CONVERSION TO NATIVE FOR spSkeletonData*
  		ok = false;
  
              if (!ok) { break; }
              cobj = new spine::SkeletonRenderer(arg0);
              cobj->autorelease();
              int ID =  (int)cobj->_ID ;
              int* luaID =  &cobj->_luaID ;
              toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)cobj,"sp.SkeletonRenderer");
              return 1;
          }
      }while(0);
      ok  = true;
      do{
          if (argc == 2) {
              spSkeletonData* arg0;
              #pragma warning NO CONVERSION TO NATIVE FOR spSkeletonData*
  		ok = false;
  
              if (!ok) { break; }
              bool arg1;
              ok &= luaval_to_boolean(tolua_S, 3,&arg1, "sp.SkeletonRenderer:SkeletonRenderer");
  
              if (!ok) { break; }
              cobj = new spine::SkeletonRenderer(arg0, arg1);
              cobj->autorelease();
              int ID =  (int)cobj->_ID ;
              int* luaID =  &cobj->_luaID ;
              toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)cobj,"sp.SkeletonRenderer");
              return 1;
          }
      }while(0);
      ok  = true;
      do{
          if (argc == 0) {
              cobj = new spine::SkeletonRenderer();
              cobj->autorelease();
              int ID =  (int)cobj->_ID ;
              int* luaID =  &cobj->_luaID ;
              toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)cobj,"sp.SkeletonRenderer");
              return 1;
          }
      }while(0);
      ok  = true;
      do{
          if (argc == 2) {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:SkeletonRenderer");
  
              if (!ok) { break; }
              spAtlas* arg1;
              #pragma warning NO CONVERSION TO NATIVE FOR spAtlas*
  		ok = false;
  
              if (!ok) { break; }
              cobj = new spine::SkeletonRenderer(arg0, arg1);
              cobj->autorelease();
              int ID =  (int)cobj->_ID ;
              int* luaID =  &cobj->_luaID ;
              toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)cobj,"sp.SkeletonRenderer");
              return 1;
          }
      }while(0);
      ok  = true;
      do{
          if (argc == 3) {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:SkeletonRenderer");
  
              if (!ok) { break; }
              spAtlas* arg1;
              #pragma warning NO CONVERSION TO NATIVE FOR spAtlas*
  		ok = false;
  
              if (!ok) { break; }
              double arg2;
              ok &= luaval_to_number(tolua_S, 4,&arg2, "sp.SkeletonRenderer:SkeletonRenderer");
  
              if (!ok) { break; }
              cobj = new spine::SkeletonRenderer(arg0, arg1, arg2);
              cobj->autorelease();
              int ID =  (int)cobj->_ID ;
              int* luaID =  &cobj->_luaID ;
              toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)cobj,"sp.SkeletonRenderer");
              return 1;
          }
      }while(0);
      ok  = true;
      do{
          if (argc == 2) {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:SkeletonRenderer");
  
              if (!ok) { break; }
              std::string arg1;
              ok &= luaval_to_std_string(tolua_S, 3,&arg1, "sp.SkeletonRenderer:SkeletonRenderer");
  
              if (!ok) { break; }
              cobj = new spine::SkeletonRenderer(arg0, arg1);
              cobj->autorelease();
              int ID =  (int)cobj->_ID ;
              int* luaID =  &cobj->_luaID ;
              toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)cobj,"sp.SkeletonRenderer");
              return 1;
          }
      }while(0);
      ok  = true;
      do{
          if (argc == 3) {
              std::string arg0;
              ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonRenderer:SkeletonRenderer");
  
              if (!ok) { break; }
              std::string arg1;
              ok &= luaval_to_std_string(tolua_S, 3,&arg1, "sp.SkeletonRenderer:SkeletonRenderer");
  
              if (!ok) { break; }
              double arg2;
              ok &= luaval_to_number(tolua_S, 4,&arg2, "sp.SkeletonRenderer:SkeletonRenderer");
  
              if (!ok) { break; }
              cobj = new spine::SkeletonRenderer(arg0, arg1, arg2);
              cobj->autorelease();
              int ID =  (int)cobj->_ID ;
              int* luaID =  &cobj->_luaID ;
              toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)cobj,"sp.SkeletonRenderer");
              return 1;
          }
      }while(0);
      ok  = true;
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n",  "sp.SkeletonRenderer:SkeletonRenderer",argc, 2);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonRenderer_constructor'.",&tolua_err);
  #endif
  
      return 0;
  }
  
  static int lua_cocos2dx_spine_SkeletonRenderer_finalize(lua_State* tolua_S)
  {
      printf("luabindings: finalizing LUA object (SkeletonRenderer)");
      return 0;
  }
  
  int lua_register_cocos2dx_spine_SkeletonRenderer(lua_State* tolua_S)
  {
      tolua_usertype(tolua_S,"sp.SkeletonRenderer");
      tolua_cclass(tolua_S,"SkeletonRenderer","sp.SkeletonRenderer","cc.Node",nullptr);
  
      tolua_beginmodule(tolua_S,"SkeletonRenderer");
          tolua_function(tolua_S,"new",lua_cocos2dx_spine_SkeletonRenderer_constructor);
          tolua_function(tolua_S,"setTimeScale",lua_cocos2dx_spine_SkeletonRenderer_setTimeScale);
          tolua_function(tolua_S,"getDebugSlotsEnabled",lua_cocos2dx_spine_SkeletonRenderer_getDebugSlotsEnabled);
          tolua_function(tolua_S,"setBonesToSetupPose",lua_cocos2dx_spine_SkeletonRenderer_setBonesToSetupPose);
          tolua_function(tolua_S,"initWithData",lua_cocos2dx_spine_SkeletonRenderer_initWithData);
          tolua_function(tolua_S,"setDebugSlotsEnabled",lua_cocos2dx_spine_SkeletonRenderer_setDebugSlotsEnabled);
          tolua_function(tolua_S,"setSlotsToSetupPose",lua_cocos2dx_spine_SkeletonRenderer_setSlotsToSetupPose);
          tolua_function(tolua_S,"setToSetupPose",lua_cocos2dx_spine_SkeletonRenderer_setToSetupPose);
          tolua_function(tolua_S,"getBlendFunc",lua_cocos2dx_spine_SkeletonRenderer_getBlendFunc);
          tolua_function(tolua_S,"initialize",lua_cocos2dx_spine_SkeletonRenderer_initialize);
          tolua_function(tolua_S,"setDebugBonesEnabled",lua_cocos2dx_spine_SkeletonRenderer_setDebugBonesEnabled);
          tolua_function(tolua_S,"getDebugBonesEnabled",lua_cocos2dx_spine_SkeletonRenderer_getDebugBonesEnabled);
          tolua_function(tolua_S,"getTimeScale",lua_cocos2dx_spine_SkeletonRenderer_getTimeScale);
          tolua_function(tolua_S,"initWithFile",lua_cocos2dx_spine_SkeletonRenderer_initWithFile);
          tolua_function(tolua_S,"setBlendFunc",lua_cocos2dx_spine_SkeletonRenderer_setBlendFunc);
          tolua_function(tolua_S,"setSkin",lua_cocos2dx_spine_SkeletonRenderer_setSkin);
          tolua_function(tolua_S,"getSkeleton",lua_cocos2dx_spine_SkeletonRenderer_getSkeleton);
          tolua_function(tolua_S,"createWithFile", lua_cocos2dx_spine_SkeletonRenderer_createWithFile);
          tolua_function(tolua_S,"create", lua_cocos2dx_spine_SkeletonRenderer_create);
      tolua_endmodule(tolua_S);
      std::string typeName = typeid(spine::SkeletonRenderer).name();
      g_luaType[typeName] = "sp.SkeletonRenderer";
      g_typeCast["SkeletonRenderer"] = "sp.SkeletonRenderer";
      return 1;
  }
  
  int lua_cocos2dx_spine_SkeletonAnimation_setStartListener(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_setStartListener'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 1) 
      {
          std::function<void (int)> arg0;
  
          do {
  			// Lambda binding for lua is not supported.
  			assert(false);
  		} while(0)
  		;
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_setStartListener'", nullptr);
              return 0;
          }
          cobj->setStartListener(arg0);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:setStartListener",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_setStartListener'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_setTrackEventListener(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackEventListener'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 2) 
      {
          spTrackEntry* arg0;
          std::function<void (int, spEvent *)> arg1;
  
          #pragma warning NO CONVERSION TO NATIVE FOR spTrackEntry*
  		ok = false;
  
          do {
  			// Lambda binding for lua is not supported.
  			assert(false);
  		} while(0)
  		;
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackEventListener'", nullptr);
              return 0;
          }
          cobj->setTrackEventListener(arg0, arg1);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:setTrackEventListener",argc, 2);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackEventListener'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_setTrackCompleteListener(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackCompleteListener'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 2) 
      {
          spTrackEntry* arg0;
          std::function<void (int, int)> arg1;
  
          #pragma warning NO CONVERSION TO NATIVE FOR spTrackEntry*
  		ok = false;
  
          do {
  			// Lambda binding for lua is not supported.
  			assert(false);
  		} while(0)
  		;
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackCompleteListener'", nullptr);
              return 0;
          }
          cobj->setTrackCompleteListener(arg0, arg1);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:setTrackCompleteListener",argc, 2);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackCompleteListener'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_setTrackStartListener(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackStartListener'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 2) 
      {
          spTrackEntry* arg0;
          std::function<void (int)> arg1;
  
          #pragma warning NO CONVERSION TO NATIVE FOR spTrackEntry*
  		ok = false;
  
          do {
  			// Lambda binding for lua is not supported.
  			assert(false);
  		} while(0)
  		;
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackStartListener'", nullptr);
              return 0;
          }
          cobj->setTrackStartListener(arg0, arg1);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:setTrackStartListener",argc, 2);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackStartListener'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_findAnimation(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_findAnimation'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 1) 
      {
          std::string arg0;
  
          ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonAnimation:findAnimation");
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_findAnimation'", nullptr);
              return 0;
          }
          spAnimation* ret = cobj->findAnimation(arg0);
          #pragma warning NO CONVERSION FROM NATIVE FOR spAnimation*;
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:findAnimation",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_findAnimation'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_setCompleteListener(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_setCompleteListener'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 1) 
      {
          std::function<void (int, int)> arg0;
  
          do {
  			// Lambda binding for lua is not supported.
  			assert(false);
  		} while(0)
  		;
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_setCompleteListener'", nullptr);
              return 0;
          }
          cobj->setCompleteListener(arg0);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:setCompleteListener",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_setCompleteListener'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_setTrackEndListener(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackEndListener'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 2) 
      {
          spTrackEntry* arg0;
          std::function<void (int)> arg1;
  
          #pragma warning NO CONVERSION TO NATIVE FOR spTrackEntry*
  		ok = false;
  
          do {
  			// Lambda binding for lua is not supported.
  			assert(false);
  		} while(0)
  		;
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackEndListener'", nullptr);
              return 0;
          }
          cobj->setTrackEndListener(arg0, arg1);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:setTrackEndListener",argc, 2);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_setTrackEndListener'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_setEventListener(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_setEventListener'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 1) 
      {
          std::function<void (int, spEvent *)> arg0;
  
          do {
  			// Lambda binding for lua is not supported.
  			assert(false);
  		} while(0)
  		;
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_setEventListener'", nullptr);
              return 0;
          }
          cobj->setEventListener(arg0);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:setEventListener",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_setEventListener'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_setMix(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_setMix'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 3) 
      {
          std::string arg0;
          std::string arg1;
          double arg2;
  
          ok &= luaval_to_std_string(tolua_S, 2,&arg0, "sp.SkeletonAnimation:setMix");
  
          ok &= luaval_to_std_string(tolua_S, 3,&arg1, "sp.SkeletonAnimation:setMix");
  
          ok &= luaval_to_number(tolua_S, 4,&arg2, "sp.SkeletonAnimation:setMix");
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_setMix'", nullptr);
              return 0;
          }
          cobj->setMix(arg0, arg1, arg2);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:setMix",argc, 3);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_setMix'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_setEndListener(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_setEndListener'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 1) 
      {
          std::function<void (int)> arg0;
  
          do {
  			// Lambda binding for lua is not supported.
  			assert(false);
  		} while(0)
  		;
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_setEndListener'", nullptr);
              return 0;
          }
          cobj->setEndListener(arg0);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:setEndListener",argc, 1);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_setEndListener'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_initialize(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_initialize'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_initialize'", nullptr);
              return 0;
          }
          cobj->initialize();
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:initialize",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_initialize'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_clearTracks(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_clearTracks'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_clearTracks'", nullptr);
              return 0;
          }
          cobj->clearTracks();
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:clearTracks",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_clearTracks'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_clearTrack(lua_State* tolua_S)
  {
      int argc = 0;
      spine::SkeletonAnimation* cobj = nullptr;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertype(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      cobj = (spine::SkeletonAnimation*)tolua_tousertype(tolua_S,1,0);
  
  #if COCOS2D_DEBUG >= 1
      if (!cobj) 
      {
          tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_spine_SkeletonAnimation_clearTrack'", nullptr);
          return 0;
      }
  #endif
  
      argc = lua_gettop(tolua_S)-1;
      if (argc == 0) 
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_clearTrack'", nullptr);
              return 0;
          }
          cobj->clearTrack();
          lua_settop(tolua_S, 1);
          return 1;
      }
      if (argc == 1) 
      {
          int arg0;
  
          ok &= luaval_to_int32(tolua_S, 2,(int *)&arg0, "sp.SkeletonAnimation:clearTrack");
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_clearTrack'", nullptr);
              return 0;
          }
          cobj->clearTrack(arg0);
          lua_settop(tolua_S, 1);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sp.SkeletonAnimation:clearTrack",argc, 0);
      return 0;
  
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_clearTrack'.",&tolua_err);
  #endif
  
      return 0;
  }
  int lua_cocos2dx_spine_SkeletonAnimation_create(lua_State* tolua_S)
  {
      int argc = 0;
      bool ok  = true;
  
  #if COCOS2D_DEBUG >= 1
      tolua_Error tolua_err;
  #endif
  
  #if COCOS2D_DEBUG >= 1
      if (!tolua_isusertable(tolua_S,1,"sp.SkeletonAnimation",0,&tolua_err)) goto tolua_lerror;
  #endif
  
      argc = lua_gettop(tolua_S) - 1;
  
      if (argc == 0)
      {
          if(!ok)
          {
              tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_spine_SkeletonAnimation_create'", nullptr);
              return 0;
          }
          spine::SkeletonAnimation* ret = spine::SkeletonAnimation::create();
          object_to_luaval<spine::SkeletonAnimation>(tolua_S, "sp.SkeletonAnimation",(spine::SkeletonAnimation*)ret);
          return 1;
      }
      luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "sp.SkeletonAnimation:create",argc, 0);
      return 0;
  #if COCOS2D_DEBUG >= 1
      tolua_lerror:
      tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_spine_SkeletonAnimation_create'.",&tolua_err);
  #endif
      return 0;
  }
  static int lua_cocos2dx_spine_SkeletonAnimation_finalize(lua_State* tolua_S)
  {
      printf("luabindings: finalizing LUA object (SkeletonAnimation)");
      return 0;
  }
  
  int lua_register_cocos2dx_spine_SkeletonAnimation(lua_State* tolua_S)
  {
      tolua_usertype(tolua_S,"sp.SkeletonAnimation");
      tolua_cclass(tolua_S,"SkeletonAnimation","sp.SkeletonAnimation","sp.SkeletonRenderer",nullptr);
  
      tolua_beginmodule(tolua_S,"SkeletonAnimation");
          tolua_function(tolua_S,"setStartListener",lua_cocos2dx_spine_SkeletonAnimation_setStartListener);
          tolua_function(tolua_S,"setTrackEventListener",lua_cocos2dx_spine_SkeletonAnimation_setTrackEventListener);
          tolua_function(tolua_S,"setTrackCompleteListener",lua_cocos2dx_spine_SkeletonAnimation_setTrackCompleteListener);
          tolua_function(tolua_S,"setTrackStartListener",lua_cocos2dx_spine_SkeletonAnimation_setTrackStartListener);
          tolua_function(tolua_S,"findAnimation",lua_cocos2dx_spine_SkeletonAnimation_findAnimation);
          tolua_function(tolua_S,"setCompleteListener",lua_cocos2dx_spine_SkeletonAnimation_setCompleteListener);
          tolua_function(tolua_S,"setTrackEndListener",lua_cocos2dx_spine_SkeletonAnimation_setTrackEndListener);
          tolua_function(tolua_S,"setEventListener",lua_cocos2dx_spine_SkeletonAnimation_setEventListener);
          tolua_function(tolua_S,"setMix",lua_cocos2dx_spine_SkeletonAnimation_setMix);
          tolua_function(tolua_S,"setEndListener",lua_cocos2dx_spine_SkeletonAnimation_setEndListener);
          tolua_function(tolua_S,"initialize",lua_cocos2dx_spine_SkeletonAnimation_initialize);
          tolua_function(tolua_S,"clearTracks",lua_cocos2dx_spine_SkeletonAnimation_clearTracks);
          tolua_function(tolua_S,"clearTrack",lua_cocos2dx_spine_SkeletonAnimation_clearTrack);
          tolua_function(tolua_S,"create", lua_cocos2dx_spine_SkeletonAnimation_create);
      tolua_endmodule(tolua_S);
      std::string typeName = typeid(spine::SkeletonAnimation).name();
      g_luaType[typeName] = "sp.SkeletonAnimation";
      g_typeCast["SkeletonAnimation"] = "sp.SkeletonAnimation";
      return 1;
  }
  TOLUA_API int register_all_cocos2dx_spine(lua_State* tolua_S)
  {
  	tolua_open(tolua_S);
  	
  	tolua_module(tolua_S,"sp",0);
  	tolua_beginmodule(tolua_S,"sp");
  
  	lua_register_cocos2dx_spine_SkeletonRenderer(tolua_S);
  	lua_register_cocos2dx_spine_SkeletonAnimation(tolua_S);
  
  	tolua_endmodule(tolua_S);
  	return 1;
  }
  
  