static int tolua_lua_cocos2dx_userext_AnimationController_new00_local(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");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
return 0;
#endif
}
int lua_cocos2dx_mycustomclass_MyCustomClass_constructor(lua_State* tolua_S)
{
int argc = 0;
MyCustomClass* cobj = nullptr;
bool ok = true;
#if COCOS2D_DEBUG >= 1
tolua_Error tolua_err;
#endif
argc = lua_gettop(tolua_S)-1;
if (argc == 0)
{
if(!ok)
{
tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_mycustomclass_MyCustomClass_constructor'", nullptr);
return 0;
}
cobj = new MyCustomClass();
tolua_pushusertype(tolua_S,(void*)cobj,"MyCustomClass");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
return 1;
}
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "MyCustomClass:MyCustomClass",argc, 0);
return 0;
#if COCOS2D_DEBUG >= 1
tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_mycustomclass_MyCustomClass_constructor'.",&tolua_err);
#endif
return 0;
}
static int tolua_tfunction_TestClass_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"TestClass",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,1,&tolua_err) ||
!tolua_isnumber(tolua_S,3,1,&tolua_err) ||
!tolua_isnumber(tolua_S,4,1,&tolua_err) ||
!tolua_isnoobj(tolua_S,5,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
float cr = ((float) tolua_tonumber(tolua_S,2,0.0f));
float cg = ((float) tolua_tonumber(tolua_S,3,0.0f));
float cb = ((float) tolua_tonumber(tolua_S,4,0.0f));
{
TestClass* tolua_ret = (TestClass*) Mtolua_new((TestClass)(cr,cg,cb));
tolua_pushusertype(tolua_S,(void*)tolua_ret,"TestClass");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
return 0;
#endif
}
static int tolua_Attack_Attack_new01_local(lua_State* tolua_S)
{
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"Attack",0,&tolua_err) ||
!tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
!tolua_isnumber(tolua_S,3,0,&tolua_err) ||
!tolua_isnumber(tolua_S,4,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,5,&tolua_err)
)
goto tolua_lerror;
else
{
std::string pattern = ((std::string) tolua_tocppstring(tolua_S,2,0));
int damage = ((int) tolua_tonumber(tolua_S,3,0));
int damageBonus = ((int) tolua_tonumber(tolua_S,4,0));
{
Attack* tolua_ret = (Attack*) Mtolua_new((Attack)(pattern,damage,damageBonus));
tolua_pushusertype(tolua_S,(void*)tolua_ret,"Attack");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
}
}
return 1;
tolua_lerror:
return tolua_Attack_Attack_new00_local(tolua_S);
}
int lua_cocos2dx_bridge_LuaBridge_constructor(lua_State* tolua_S)
{
int argc = 0;
LuaBridge* cobj = nullptr;
bool ok = true;
#if COCOS2D_DEBUG >= 1
tolua_Error tolua_err;
#endif
argc = lua_gettop(tolua_S)-1;
if (argc == 0)
{
if(!ok)
return 0;
cobj = new LuaBridge();
tolua_pushusertype(tolua_S,(void*)cobj,"LuaBridge");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
return 1;
}
CCLOG("%s has wrong number of arguments: %d, was expecting %d \n", "LuaBridge",argc, 0);
return 0;
#if COCOS2D_DEBUG >= 1
tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_bridge_LuaBridge_constructor'.",&tolua_err);
#endif
return 0;
}
int lua_PluginGoogleAnalyticsLua_PluginGoogleAnalytics_constructor(lua_State* tolua_S)
{
int argc = 0;
sdkbox::PluginGoogleAnalytics* cobj = nullptr;
bool ok = true;
#if COCOS2D_DEBUG >= 1
tolua_Error tolua_err;
#endif
argc = lua_gettop(tolua_S)-1;
if (argc == 0)
{
if(!ok)
{
tolua_error(tolua_S,"invalid arguments in function 'lua_PluginGoogleAnalyticsLua_PluginGoogleAnalytics_constructor'", nullptr);
return 0;
}
cobj = new sdkbox::PluginGoogleAnalytics();
tolua_pushusertype(tolua_S,(void*)cobj,"sdkbox.PluginGoogleAnalytics");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
return 1;
}
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "sdkbox.PluginGoogleAnalytics:PluginGoogleAnalytics",argc, 0);
return 0;
#if COCOS2D_DEBUG >= 1
tolua_error(tolua_S,"#ferror in function 'lua_PluginGoogleAnalyticsLua_PluginGoogleAnalytics_constructor'.",&tolua_err);
#endif
return 0;
}
int lua_cocos2dx_audioengine_AudioProfile_constructor(lua_State* tolua_S)
{
int argc = 0;
cocos2d::experimental::AudioProfile* cobj = nullptr;
bool ok = true;
#if COCOS2D_DEBUG >= 1
tolua_Error tolua_err;
#endif
argc = lua_gettop(tolua_S)-1;
if (argc == 0)
{
if(!ok)
{
tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_audioengine_AudioProfile_constructor'", nullptr);
return 0;
}
cobj = new cocos2d::experimental::AudioProfile();
tolua_pushusertype(tolua_S,(void*)cobj,"ccexp.AudioProfile");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
return 1;
}
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "ccexp.AudioProfile:AudioProfile",argc, 0);
return 0;
#if COCOS2D_DEBUG >= 1
tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_audioengine_AudioProfile_constructor'.",&tolua_err);
#endif
return 0;
}
static int tolua_lok_ok_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"ok",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
{
ok* tolua_ret = (ok*) Mtolua_new((ok)());
tolua_pushusertype(tolua_S,(void*)tolua_ret,"ok");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
return 0;
#endif
}
TOLUA_API void tolua_pushfieldusertype_and_takeownership (lua_State* L, int lo, int index, void* v, const char* type)
{
lua_pushnumber(L,index);
tolua_pushusertype(L,v,type);
tolua_register_gc(L,lua_gettop(L));
lua_settable(L,lo);
}
static int tolua_Attack_Attack_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"Attack",0,&tolua_err) ||
!tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
!tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
!tolua_isnumber(tolua_S,4,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,5,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
std::string name = ((std::string) tolua_tocppstring(tolua_S,2,0));
std::string pattern = ((std::string) tolua_tocppstring(tolua_S,3,0));
int damage = ((int) tolua_tonumber(tolua_S,4,0));
{
Attack* tolua_ret = (Attack*) Mtolua_new((Attack)(name,pattern,damage));
tolua_pushusertype(tolua_S,(void*)tolua_ret,"Attack");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
return 0;
#endif
}
int lua_cocos2dx_csloader_CSLoader_constructor(lua_State* tolua_S)
{
int argc = 0;
cocos2d::CSLoader* cobj = nullptr;
bool ok = true;
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
#endif
argc = lua_gettop(tolua_S)-1;
if (argc == 0)
{
if(!ok)
{
tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_csloader_CSLoader_constructor'", nullptr);
return 0;
}
cobj = new cocos2d::CSLoader();
tolua_pushusertype(tolua_S,(void*)cobj,"cc.CSLoader");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
return 1;
}
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.CSLoader:CSLoader",argc, 0);
return 0;
#ifndef TOLUA_RELEASE
tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_csloader_CSLoader_constructor'.",&tolua_err);
#endif
return 0;
}
static int tolua_HeroControl_PH_HeroControl_getColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"PH::HeroControl",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
PH::HeroControl* self = (PH::HeroControl*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColor'", NULL);
#endif
{
PH::GemUtils::GemColor tolua_ret = (PH::GemUtils::GemColor) self->getColor();
{
#ifdef __cplusplus
void* tolua_obj = Mtolua_new((PH::GemUtils::GemColor)(tolua_ret));
tolua_pushusertype(tolua_S,tolua_obj,"PH::GemUtils::GemColor");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(PH::GemUtils::GemColor));
tolua_pushusertype(tolua_S,tolua_obj,"PH::GemUtils::GemColor");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
}
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'getColor'.",&tolua_err);
return 0;
#endif
}
template<typename T> int tolua_pushurho3dpodvectorusertype(lua_State* L, const PODVector<T>& vector, const char* typeName)
{
lua_newtable(L);
for (unsigned i = 0; i < vector.Size(); ++i)
{
void* tolua_obj = Mtolua_new((T)(vector[i]));
tolua_pushusertype(L, tolua_obj, typeName);
tolua_register_gc(L,lua_gettop(L));
lua_rawseti(L, -2, i + 1);
}
return 1;
}
/** Binds cNetwork::Listen */
static int tolua_cNetwork_Listen(lua_State * L)
{
// Function signature:
// cNetwork:Listen(Port, Callbacks) -> cServerHandle
cLuaState S(L);
if (
!S.CheckParamUserTable(1, "cNetwork") ||
!S.CheckParamNumber(2) ||
!S.CheckParamTable(3) ||
!S.CheckParamEnd(4)
)
{
return 0;
}
// Get the plugin instance:
cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
if (Plugin == nullptr)
{
// An error message has been already printed in GetLuaPlugin()
S.Push(false);
return 1;
}
// Read the params:
int Port;
S.GetStackValues(2, Port);
if ((Port < 0) || (Port > 65535))
{
LOGWARNING("cNetwork:Listen() called with invalid port (%d), failing the request.", Port);
S.Push(false);
return 1;
}
UInt16 Port16 = static_cast<UInt16>(Port);
// Create the LuaTCPLink glue class:
auto Srv = std::make_shared<cLuaServerHandle>(Port16, *Plugin, 3);
// Listen:
Srv->SetServerHandle(cNetwork::Listen(Port16, Srv), Srv);
// Register the server to be garbage-collected by Lua:
tolua_pushusertype(L, Srv.get(), "cServerHandle");
tolua_register_gc(L, lua_gettop(L));
// Return the server handle wrapper:
S.Push(Srv.get());
return 1;
}
/** Binds cNetwork::CreateUDPEndpoint */
static int tolua_cNetwork_CreateUDPEndpoint(lua_State * L)
{
// Function signature:
// cNetwork:CreateUDPEndpoint(Port, Callbacks) -> cUDPEndpoint
cLuaState S(L);
if (
!S.CheckParamUserTable(1, "cNetwork") ||
!S.CheckParamNumber(2) ||
!S.CheckParamTable(3) ||
!S.CheckParamEnd(4)
)
{
return 0;
}
// Get the plugin instance:
cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
if (Plugin == nullptr)
{
// An error message has been already printed in GetLuaPlugin()
S.Push(false);
return 1;
}
// Read the params:
UInt16 Port;
// Check validity:
if (!S.GetStackValues(2, Port))
{
LOGWARNING("cNetwork:CreateUDPEndpoint() called with invalid port, failing the request.");
S.Push(false);
return 1;
}
// Create the LuaUDPEndpoint glue class:
auto Endpoint = std::make_shared<cLuaUDPEndpoint>(*Plugin, 3);
Endpoint->Open(Port, Endpoint);
// Register the endpoint to be garbage-collected by Lua:
tolua_pushusertype(L, Endpoint.get(), "cUDPEndpoint");
tolua_register_gc(L, lua_gettop(L));
// Return the endpoint object:
S.Push(Endpoint.get());
return 1;
}
/* Take ownership
*/
static int tolua_bnd_takeownership (lua_State* L)
{
int success = 0;
if (lua_isuserdata(L,1))
{
if (lua_getmetatable(L,1)) /* if metatable? */
{
lua_pop(L,1); /* clear metatable off stack */
/* force garbage collection to avoid C to reuse a to-be-collected address */
lua_setgcthreshold(L,0);
success = tolua_register_gc(L,1);
}
}
lua_pushboolean(L,success!=0);
return 1;
}
/** Binds cNetwork::Listen */
static int tolua_cNetwork_Listen(lua_State * L)
{
// Function signature:
// cNetwork:Listen(Port, Callbacks) -> cServerHandle
cLuaState S(L);
if (
!S.CheckParamStaticSelf("cNetwork") ||
!S.CheckParamNumber(2) ||
!S.CheckParamTable(3) ||
!S.CheckParamEnd(4)
)
{
return 0;
}
// Read the params:
int port = 0;
cLuaState::cTableRefPtr callbacks;
if (!S.GetStackValues(2, port, callbacks))
{
return S.ApiParamError("Cannot read parameters");
}
// Check the validity:
if ((port < 0) || (port > 65535))
{
return S.ApiParamError("Port number out of range (%d, range 0 - 65535)", port);
}
auto port16 = static_cast<UInt16>(port);
// Create the LuaTCPLink glue class:
auto srv = std::make_shared<cLuaServerHandle>(port16, std::move(callbacks));
// Listen:
srv->SetServerHandle(cNetwork::Listen(port16, srv), srv);
// Register the server to be garbage-collected by Lua:
tolua_pushusertype(L, srv.get(), "cServerHandle");
tolua_register_gc(L, lua_gettop(L));
// Return the server handle wrapper:
S.Push(srv.get());
return 1;
}
int lua_glue_auto_GlDisplayService_constructor(lua_State* L)
{
bool ok = true;
glfw::GlfwContext* context;
ok &= luaval_to_object<glfw::GlfwContext>(L, 1, "glfw.GlfwContext", &context, "display.GlDisplayService:GlDisplayService");
if (!ok)
{
tolua_error(L, "invalid arguments in function 'lua_glue_auto_GlDisplayService_constructor'", nullptr);
return 0;
}
display::GlDisplayService* cobj = new display::GlDisplayService(*context);
tolua_pushusertype(L, (void*)cobj, "display.GlDisplayService");
tolua_register_gc(L, lua_gettop(L));
return 1;
}
/** Binds cNetwork::CreateUDPEndpoint */
static int tolua_cNetwork_CreateUDPEndpoint(lua_State * L)
{
// Function signature:
// cNetwork:CreateUDPEndpoint(Port, Callbacks) -> cUDPEndpoint
cLuaState S(L);
if (
!S.CheckParamStaticSelf("cNetwork") ||
!S.CheckParamNumber(2) ||
!S.CheckParamTable(3) ||
!S.CheckParamEnd(4)
)
{
return 0;
}
// Read the params:
int port;
cLuaState::cTableRefPtr callbacks;
if (!S.GetStackValues(2, port, callbacks))
{
return S.ApiParamError("Cannot read parameters");
}
// Check validity:
if ((port < 0) || (port > 65535))
{
return S.ApiParamError("Port number out of range (%d, range 0 - 65535)", port);
}
ASSERT(callbacks != nullptr); // Invalid callbacks would have resulted in GetStackValues() returning false
// Create the LuaUDPEndpoint glue class:
auto endpoint = std::make_shared<cLuaUDPEndpoint>(std::move(callbacks));
endpoint->Open(static_cast<UInt16>(port), endpoint);
// Register the endpoint to be garbage-collected by Lua:
tolua_pushusertype(L, endpoint.get(), "cUDPEndpoint");
tolua_register_gc(L, lua_gettop(L));
// Return the endpoint object:
S.Push(endpoint.get());
return 1;
}
static int tolua_GUID_CGUID_new01_local(lua_State* tolua_S)
{
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"CGUID",0,&tolua_err) ||
!tolua_isstring(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
{
const char* str = ((const char*) tolua_tostring(tolua_S,2,0));
{
CGUID* tolua_ret = (CGUID*) Mtolua_new((CGUID)(str));
tolua_pushusertype(tolua_S,(void*)tolua_ret,"CGUID");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
}
}
return 1;
tolua_lerror:
return tolua_GUID_CGUID_new00_local(tolua_S);
}
void Stack::registerGCForTopObject() {
assert(getTypeAt(getSize()) == kTypeUserType);
tolua_register_gc(&_luaState, getSize());
}
void ToluaPushVariant(lua_State* L, const Variant* variant, const char* type)
{
String typeName(type);
switch (variant->GetType())
{
case VAR_INT:
if (typeName == "unsigned" || typeName == "unsigned int" || typeName == "UInt" || typeName == "uint")
tolua_pushnumber(L, (lua_Number)variant->GetUInt());
else if (typeName == "StringHash")
{
// Make a new local copy
tolua_pushusertype(L, Mtolua_new(StringHash(variant->GetStringHash())), "StringHash");
tolua_register_gc(L, lua_gettop(L));
}
else
tolua_pushnumber(L, (lua_Number)variant->GetInt());
break;
case VAR_BOOL:
tolua_pushboolean(L, (int)variant->GetBool());
break;
case VAR_FLOAT:
tolua_pushnumber(L, (lua_Number)variant->GetFloat());
break;
case VAR_DOUBLE:
tolua_pushnumber(L, (lua_Number)variant->GetDouble());
break;
case VAR_VECTOR2:
case VAR_VECTOR3:
case VAR_VECTOR4:
case VAR_QUATERNION:
case VAR_COLOR:
case VAR_RESOURCEREF:
case VAR_RESOURCEREFLIST:
case VAR_VARIANTMAP:
case VAR_INTRECT:
case VAR_INTVECTOR2:
tolua_pushusertype(L, (void*)variant->Get<const VariantValue*>(), variant->GetTypeName().CString());
break;
case VAR_STRING:
tolua_pushurho3dstring(L, variant->GetString());
break;
case VAR_BUFFER:
if (typeName == "VectorBuffer")
{
tolua_pushusertype(L, Mtolua_new(VectorBuffer(variant->GetVectorBuffer())), "VectorBuffer");
tolua_register_gc(L, lua_gettop(L));
}
else
ToluaPushPODVector<unsigned char>(0.f, L, (void*)&variant->GetBuffer(), "unsigned char");
break;
case VAR_VOIDPTR:
ToluaPushRegisteredUserType(L, static_cast<void*>(variant->GetVoidPtr()), type);
break;
case VAR_PTR:
ToluaPushRegisteredUserType(L, static_cast<void*>(variant->GetPtr()), type);
break;
case VAR_VARIANTVECTOR:
ToluaPushVector<Variant>(L, (void*)&variant->GetVariantVector(), "Variant");
break;
case VAR_STRINGVECTOR:
ToluaPushVector<String>(L, (void*)&variant->GetStringVector(), "String");
break;
case VAR_MATRIX3:
case VAR_MATRIX3X4:
case VAR_MATRIX4:
tolua_pushusertype(L, variant->Get<const VariantValue*>()->ptr_, variant->GetTypeName().CString());
break;
default:
lua_pushnil(L);
break;
}
}
TOLUA_API void tolua_pushusertype_and_takeownership (lua_State* L, void* value, const char* type)
{
tolua_pushusertype(L,value,type);
tolua_register_gc(L,lua_gettop(L));
}
