Пример #1
0
static int tolua_CCGUI_MCCUtil_checkNet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MCCUtil",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   int tolua_ret = (int)  MCCUtil::checkNet();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'checkNet'.",&tolua_err);
 return 0;
#endif
}
Пример #2
0
static int tolua_glu_gluDeleteQuadric00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GLUquadricObj",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GLUquadricObj* state = ((GLUquadricObj*)  tolua_tousertype(tolua_S,1,0));
  {
   gluDeleteQuadric(state);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'gluDeleteQuadric'.",&tolua_err);
 return 0;
#endif
}
Пример #3
0
static int tolua_glu_gluDeleteNurbsRenderer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GLUnurbsObj",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GLUnurbsObj* nobj = ((GLUnurbsObj*)  tolua_tousertype(tolua_S,1,0));
  {
   gluDeleteNurbsRenderer(nobj);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'gluDeleteNurbsRenderer'.",&tolua_err);
 return 0;
#endif
}
Пример #4
0
static int tolua_lua_cocos2dx_userext_EntityComponent_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EntityComponent",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EntityComponent* tolua_ret = (EntityComponent*)  EntityComponent::create();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EntityComponent");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
Пример #5
0
static int tolua_lua_cocos2dx_userext_LuaValueList_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"LuaValueList",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   LuaValueList* tolua_ret = (LuaValueList*)  Mtolua_new((LuaValueList)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"LuaValueList");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
static int tolua_Interface_Overseer_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"Overseer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  Overseer& tolua_ret = (Overseer&)  Overseer::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Overseer");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
int lua_glue_auto_GlDisplayService_createWindow(lua_State* L)
{
    display::GlDisplayService* cobj = (display::GlDisplayService*)tolua_tousertype(L, 1, 0);
    bool ok = true;

    int width;
    int height;
    const char* title;

    ok &= luaval_to_int32(L, 2, (int *)&width, "display.GlDisplayService:createWindow");

    ok &= luaval_to_int32(L, 3, (int *)&height, "display.GlDisplayService:createWindow");

    std::string title_tmp; ok &= luaval_to_std_string(L, 4, &title_tmp, "display.GlDisplayService:createWindow"); title = title_tmp.c_str();

    if (!ok)
    {
        tolua_error(L, "invalid arguments in function 'lua_glue_auto_GlDisplayService_createWindow'", nullptr);
        return 0;
    }
    int ret = cobj->createWindow(width, height, title);
    tolua_pushnumber(L, (lua_Number)ret);
    return 1;
}
Пример #8
0
static int do_operator (lua_State* L, const char* op)
{
	if (lua_isuserdata(L,1))
	{
		/* Try metatables */
		lua_pushvalue(L,1);                     /* stack: op1 op2 */
		while (lua_getmetatable(L,-1))
		{                                       /* stack: op1 op2 op1 mt */
			lua_remove(L,-2);                      /* stack: op1 op2 mt */
			lua_pushstring(L,op);                  /* stack: op1 op2 mt key */
			lua_rawget(L,-2);                      /* stack: obj key mt func */
			if (lua_isfunction(L,-1))
			{
				lua_pushvalue(L,1);
				lua_pushvalue(L,2);
				lua_call(L,2,1);
				return 1;
			}
			lua_settop(L,3);
		}
	}
	tolua_error(L,"Attempt to perform operation on an invalid operand",NULL);
	return 0;
}
static int tolua_MessageHandler_kickOffFromRoom(lua_State *tolua_S)
{
#ifndef TOLUA_TXGUI_RELEASE
	tolua_Error tolua_err;
	if(
		!tolua_isusertype(tolua_S,1,"MessageHandler",0,&tolua_err) ||
		!tolua_isnumber(tolua_S, 2, 0, &tolua_err) ||
		!tolua_isnoobj(tolua_S,3,&tolua_err)
		)
	{
		tolua_error(tolua_S,"#ferror in function 'MessageHandler::kickOffFromRoom'",&tolua_err);
		return 0;
	}
#endif

	MessageHandler* self = (MessageHandler*)tolua_tousertype(tolua_S,1,0);	
	if (self)
	{
		int seat = tolua_tonumber(tolua_S, 2, 0);
		PPVEMessage::Get()->kickOffGuest(seat);	
	}

	return 1;
}
Пример #10
0
static int tolua_common_wyDevice_getDeviceId00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"wyDevice",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   const char* tolua_ret = (const char*)  wyDevice::getDeviceId();
   tolua_pushstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDeviceId'.",&tolua_err);
 return 0;
#endif
}
Пример #11
0
static int tolua_PushOneLayer(lua_State *tolua_S)
{
#ifndef TOLUA_TXGUI_RELEASE
	tolua_Error tolua_err;
	if(
		!tolua_isusertype(tolua_S,1,"CCLayer",0,&tolua_err) ||
		!tolua_isstring(tolua_S, 2, 0, &tolua_err) ||
		!tolua_isstring(tolua_S, 3, 0, &tolua_err) ||
		!tolua_isnoobj(tolua_S, 4, &tolua_err)
		)
	{
		tolua_error(tolua_S,"#ferror in function 'PushOneLayer'",&tolua_err);
		return 0;
	}
#endif

	CCLayer* layer = (CCLayer*)(tolua_tousertype(tolua_S, 1, NULL));
	std::string param_1 = tolua_tostring(tolua_S,2,NULL);
	std::string param_2 = tolua_tostring(tolua_S,3,NULL);

	MainMenuLayer::PushOneLayer(layer,param_1,param_2);

	return 0;
}
Пример #12
0
/* method: new of class  myClass */
static int tolua_toexport_myClass_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"myClass",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  myClass* tolua_ret = (myClass*)  new myClass();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"myClass");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
Пример #13
0
static int tolua_LuaMainAPI_API_LoadLuaFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  char* szLUAFileName = ((char*)  tolua_tostring(tolua_S,1,0));
  {
   API_LoadLuaFile(szLUAFileName);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'API_LoadLuaFile'.",&tolua_err);
 return 0;
#endif
}
Пример #14
0
static int tolua_gl_gl_glClear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned int tolua_var_5 = ((unsigned int)  tolua_tonumber(tolua_S,1,0));
  {
   glClear(tolua_var_5);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'glClear'.",&tolua_err);
 return 0;
#endif
}
static int tolua__IntensityCEGUI_luaFocusOnEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  int uniqueId = ((int)  tolua_tonumber(tolua_S,1,0));
 {
  IntensityCEGUI::luaFocusOnEntity(uniqueId);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'luaFocusOnEntity'.",&tolua_err);
 return 0;
#endif
}
static int tolua_MessageHandler_pvp_setReady(lua_State *tolua_S)
{
#ifndef TOLUA_TXGUI_RELEASE
	tolua_Error tolua_err;
	if(
       !tolua_isusertype(tolua_S,1,"MessageHandler",0,&tolua_err) ||
       !tolua_isboolean(tolua_S, 2, 0, &tolua_err) ||
       !tolua_isnoobj(tolua_S,3,&tolua_err)
       )
	{
		tolua_error(tolua_S,"#ferror in function 'MessageHandler::setReady'",&tolua_err);
		return 0;
	}
#endif
    
	MessageHandler* self = (MessageHandler*)tolua_tousertype(tolua_S,1,0);
	if (self)
	{
		bool bReady = tolua_toboolean(tolua_S, 2, 0) != 0;
		/// send get room list request
		PVPMessage::Get()->pvp_setReady(bReady);
	}
	return 1;
}
static int tolua__IntensityCEGUI_luaApplySoundSettings00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* settingsWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,1,0));
 {
  IntensityCEGUI::luaApplySoundSettings(settingsWindow);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'luaApplySoundSettings'.",&tolua_err);
 return 0;
#endif
}
Пример #18
0
/* function: music_play_music */
static int toluaI_sound_sound___play_music00(lua_State* tolua_S)
{
 if (
 !tolua_istype(tolua_S,1,tolua_tag(tolua_S,"Mix_Music"),0) ||
 !tolua_istype(tolua_S,2,LUA_TNUMBER,0) ||
 !tolua_istype(tolua_S,3,LUA_TNUMBER,0) ||
 !tolua_isnoobj(tolua_S,4)
 )
 goto tolua_lerror;
 else
 {
  Mix_Music* music = ((Mix_Music*)  tolua_getusertype(tolua_S,1,0));
  s32b loop = ((s32b)  tolua_getnumber(tolua_S,2,0));
  s32b fade_in_time = ((s32b)  tolua_getnumber(tolua_S,3,0));
 {
  bool toluaI_ret = (bool)  music_play_music(music,loop,fade_in_time);
 tolua_pushbool(tolua_S,(int)toluaI_ret);
 }
 }
 return 1;
tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '__play_music'.");
 return 0;
}
int lua_glue_auto_GlDisplayService_addWindowCloseListener(lua_State* L)
{
    display::GlDisplayService* cobj = (display::GlDisplayService*)tolua_tousertype(L, 1, 0);
    bool ok = true;

    std::function<void (int)> listener;

    int listenerFunc = toluafix_ref_function(L, 2, 0);
		
		listener = [=](int larg0) -> void {
		    toluafix_get_function_by_refid(L, listenerFunc);
		    tolua_pushnumber(L, (lua_Number)larg0);
		    LuaStack::executeFunction(L, 1);
		};

    if (!ok)
    {
        tolua_error(L, "invalid arguments in function 'lua_glue_auto_GlDisplayService_addWindowCloseListener'", nullptr);
        return 0;
    }
    int ret = cobj->addWindowCloseListener(listener);
    tolua_pushnumber(L, (lua_Number)ret);
    return 1;
}
Пример #20
0
static int tolua_Level_Level_addActor01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Level",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Ghost",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Level* self = (Level*)  tolua_tousertype(tolua_S,1,0);
  Ghost* node = ((Ghost*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addActor'", NULL);
#endif
  {
   self->addActor(node);
  }
 }
 return 0;
tolua_lerror:
 return tolua_Level_Level_addActor00(tolua_S);
}
Пример #21
0
static int tolua_AppstorePurchase_CAppstorePurchase_getInstance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CAppstorePurchase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CAppstorePurchase* tolua_ret = (CAppstorePurchase*)  CAppstorePurchase::getInstance();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CAppstorePurchase");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInstance'.",&tolua_err);
 return 0;
#endif
}
static int tolua__IntensityCEGUI_luaSetRightWeaponSparkle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  int id = ((int)  tolua_tonumber(tolua_S,1,0));
 {
  IntensityCEGUI::luaSetRightWeaponSparkle(id);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'luaSetRightWeaponSparkle'.",&tolua_err);
 return 0;
#endif
}
Пример #23
0
static int tolua_lua_cocos2dx_userext_AnimationController_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"AnimationController",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   AnimationController* tolua_ret = (AnimationController*)  Mtolua_new((AnimationController)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"AnimationController");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
static int tolua__IntensityCEGUI_luaExecutePythonScript00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  std::string script = ((std::string)  tolua_tocppstring(tolua_S,1,0));
 {
  IntensityCEGUI::luaExecutePythonScript(script);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'luaExecutePythonScript'.",&tolua_err);
 return 0;
#endif
}
Пример #25
0
static int tolua_tfunction_Role_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Role",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Role* tolua_ret = (Role*)  Mtolua_new((Role)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Role");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
static int tolua__IntensityCEGUI_queueEntityCreation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  std::string _class = ((std::string)  tolua_tocppstring(tolua_S,1,0));
 {
  IntensityCEGUI::queueEntityCreation(_class);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'queueEntityCreation'.",&tolua_err);
 return 0;
#endif
}
Пример #27
0
static int tolua_glu_gluPartialDisk00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GLUquadricObj",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GLUquadricObj* qobj = ((GLUquadricObj*)  tolua_tousertype(tolua_S,1,0));
   double innerRadius = ((  double)  tolua_tonumber(tolua_S,2,0));
   double outerRadius = ((  double)  tolua_tonumber(tolua_S,3,0));
   int slices = ((  int)  tolua_tonumber(tolua_S,4,0));
   int loops = ((  int)  tolua_tonumber(tolua_S,5,0));
   double startAngle = ((  double)  tolua_tonumber(tolua_S,6,0));
   double sweepAngle = ((  double)  tolua_tonumber(tolua_S,7,0));
  {
   gluPartialDisk(qobj,innerRadius,outerRadius,slices,loops,startAngle,sweepAngle);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'gluPartialDisk'.",&tolua_err);
 return 0;
#endif
}
static int tolua__IntensityCEGUI_luaPopulateEntityList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* entityListWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,1,0));
 {
  IntensityCEGUI::luaPopulateEntityList(entityListWindow);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'luaPopulateEntityList'.",&tolua_err);
 return 0;
#endif
}
Пример #29
0
/* method: new of class  Level1Scene */
static int tolua_Level1SceneLua_Level1Scene_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertable(tolua_S,1,"Level1Scene",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        {
            Level1Scene* tolua_ret = (Level1Scene*)  new Level1Scene();
            tolua_pushusertype(tolua_S,(void*)tolua_ret,"Level1Scene");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
    return 0;
#endif
}
Пример #30
0
static int tolua_CCGUI_MCCUtil_isEnglish00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"MCCUtil",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   bool tolua_ret = (bool)  MCCUtil::isEnglish();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isEnglish'.",&tolua_err);
 return 0;
#endif
}