axmol/extensions/scripting/lua-bindings/manual/physics/axlua_physics_manual.cpp

1784 lines
54 KiB
C++
Raw Normal View History

2019-11-23 20:27:39 +08:00
/****************************************************************************
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
Copyright (c) 2019-present Axmol Engine contributors (see AUTHORS.md).
2021-10-11 12:15:41 +08:00
2022-10-01 16:24:52 +08:00
https://axmolengine.github.io/
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "lua-bindings/manual/base/axlua_base_manual.hpp"
2019-11-23 20:27:39 +08:00
#if defined(AX_ENABLE_PHYSICS)
# include "lua-bindings/manual/tolua_fix.h"
# include "lua-bindings/manual/LuaBasicConversions.h"
# include "lua-bindings/manual/LuaValue.h"
# include "lua-bindings/manual/LuaEngine.h"
# include "2d/Scene.h"
2021-12-25 10:04:45 +08:00
2022-07-16 10:43:05 +08:00
# ifndef AX_SAFE_DELETE_ARRAY
2021-12-25 10:04:45 +08:00
# define do \
{ \
if (p) \
{ \
delete[](p); \
(p) = nullptr; \
} \
} \
while (0)
# endif
2019-11-23 20:27:39 +08:00
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsBody_getJoints(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
int argc = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsBody* cobj = nullptr;
2021-12-25 10:04:45 +08:00
bool ok = true;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.PhysicsBody", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2022-08-08 18:02:17 +08:00
cobj = (ax::PhysicsBody*)tolua_tousertype(tolua_S, 1, 0);
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
if (!cobj)
{
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "invalid 'cobj' in function 'axlua_physics_PhysicsBody_getJoints'", NULL);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
argc = lua_gettop(tolua_S) - 1;
2019-11-23 20:27:39 +08:00
if (argc == 0)
{
2021-12-25 10:04:45 +08:00
do
{
if (!ok)
2019-11-23 20:27:39 +08:00
return 0;
auto& ret = cobj->getJoints();
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
lua_newtable(tolua_S);
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (ret.empty())
return 1;
2021-12-25 10:04:45 +08:00
auto iter = ret.begin();
int indexTable = 1;
2019-11-23 20:27:39 +08:00
for (; iter != ret.end(); ++iter)
{
if (nullptr == *iter)
continue;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
lua_pushnumber(tolua_S, (lua_Number)indexTable);
2022-07-12 21:31:54 +08:00
tolua_pushusertype(tolua_S, (void*)(*iter), getLuaTypeName(*iter, "ax.PhysicsJoint"));
2019-11-23 20:27:39 +08:00
lua_rawset(tolua_S, -3);
++indexTable;
}
} while (0);
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "getJoints", argc, 0);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsBody_getJoints'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsWorld_getScene(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
int argc = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsWorld* cobj = nullptr;
2021-10-11 12:15:41 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.PhysicsWorld", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2022-08-08 18:02:17 +08:00
cobj = (ax::PhysicsWorld*)tolua_tousertype(tolua_S, 1, 0);
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
if (!cobj)
{
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "invalid 'cobj' in function 'axlua_physics_PhysicsWorld_getScene'", NULL);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
argc = lua_gettop(tolua_S) - 1;
2019-11-23 20:27:39 +08:00
if (argc == 0)
{
2022-08-08 18:02:17 +08:00
ax::Scene& ret = cobj->getScene();
2021-12-25 10:04:45 +08:00
do
{
auto className = getLuaTypeName<Object>(&ret, "ax.Scene");
2021-12-25 10:04:45 +08:00
int ID = (int)(ret._ID);
2019-11-23 20:27:39 +08:00
int* luaID = &(ret._luaID);
toluafix_pushusertype_object(tolua_S, ID, luaID, (void*)(&ret), className);
2021-12-25 10:04:45 +08:00
} while (0);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "getScene", argc, 0);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsWorld_getScene'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsWorld_rayCast(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
int argc = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsWorld* cobj = nullptr;
2021-12-25 10:04:45 +08:00
bool ok = true;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.PhysicsWorld", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2022-08-08 18:02:17 +08:00
cobj = (ax::PhysicsWorld*)tolua_tousertype(tolua_S, 1, 0);
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
if (!cobj)
{
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "invalid 'cobj' in function 'axlua_physics_PhysicsWorld_rayCast'", NULL);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
argc = lua_gettop(tolua_S) - 1;
2019-11-23 20:27:39 +08:00
if (argc == 3)
{
2022-08-08 18:02:17 +08:00
std::function<bool(ax::PhysicsWorld&, const ax::PhysicsRayCastInfo&, void*)> arg0;
ax::Vec2 arg1;
ax::Vec2 arg2;
2019-11-23 20:27:39 +08:00
LUA_FUNCTION handler = toluafix_ref_function(tolua_S, 2, 0);
2022-07-20 18:41:33 +08:00
auto stack = LuaEngine::getInstance()->getLuaStack();
2021-12-25 10:04:45 +08:00
do
{
2022-08-08 18:02:17 +08:00
arg0 = [handler, stack](ax::PhysicsWorld& world, const ax::PhysicsRayCastInfo& info,
2021-12-25 10:04:45 +08:00
void* data) -> bool {
2022-07-20 18:41:33 +08:00
2021-12-25 10:04:45 +08:00
auto Ls = stack->getLuaState();
2022-07-12 21:31:54 +08:00
tolua_pushusertype(Ls, (void*)(&world), getLuaTypeName(&world, "ax.PhysicsWorld"));
2021-11-15 19:05:08 +08:00
physics_raycastinfo_to_luaval(Ls, info);
return stack->executeFunctionByHandler(handler, 2);
2019-11-23 20:27:39 +08:00
};
2021-12-25 10:04:45 +08:00
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_vec2(tolua_S, 3, &arg1, "ax.PhysicsWorld:rayCast");
ok &= luaval_to_vec2(tolua_S, 4, &arg2, "ax.PhysicsWorld:rayCast");
2021-12-25 10:04:45 +08:00
if (!ok)
2022-07-20 18:41:33 +08:00
{
stack->removeScriptHandler(handler);
2019-11-23 20:27:39 +08:00
return 0;
2022-07-20 18:41:33 +08:00
}
2019-11-23 20:27:39 +08:00
cobj->rayCast(arg0, arg1, arg2, nullptr);
2022-07-20 18:41:33 +08:00
stack->removeScriptHandler(handler);
2019-11-23 20:27:39 +08:00
lua_settop(tolua_S, 1);
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "rayCast", argc, 4);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsWorld_rayCast'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsWorld_queryRect(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
int argc = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsWorld* cobj = nullptr;
2021-12-25 10:04:45 +08:00
bool ok = true;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.PhysicsWorld", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2022-08-08 18:02:17 +08:00
cobj = (ax::PhysicsWorld*)tolua_tousertype(tolua_S, 1, 0);
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
if (!cobj)
{
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "invalid 'cobj' in function 'axlua_physics_PhysicsWorld_queryRect'", NULL);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
argc = lua_gettop(tolua_S) - 1;
2019-11-23 20:27:39 +08:00
if (argc == 2)
{
2022-08-08 18:02:17 +08:00
std::function<bool(ax::PhysicsWorld&, ax::PhysicsShape&, void*)> arg0;
ax::Rect arg1;
2019-11-23 20:27:39 +08:00
LUA_FUNCTION handler = toluafix_ref_function(tolua_S, 2, 0);
2022-07-20 18:41:33 +08:00
auto stack = LuaEngine::getInstance()->getLuaStack();
2021-12-25 10:04:45 +08:00
do
{
2022-08-08 18:02:17 +08:00
arg0 = [handler,stack](ax::PhysicsWorld& world, ax::PhysicsShape& shape, void* data) -> bool {
2022-07-20 18:41:33 +08:00
2021-12-25 10:04:45 +08:00
auto Ls = stack->getLuaState();
2022-07-12 21:31:54 +08:00
tolua_pushusertype(Ls, (void*)(&world), getLuaTypeName(&world, "ax.PhysicsWorld"));
toluafix_pushusertype_object(Ls, shape._ID, &shape._luaID, (void*)(&shape), "ax.PhysicsShape");
2021-11-15 19:05:08 +08:00
return stack->executeFunctionByHandler(handler, 2);
2019-11-23 20:27:39 +08:00
};
2021-12-25 10:04:45 +08:00
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_rect(tolua_S, 3, &arg1, "ax.PhysicsWorld:queryRect");
2021-12-25 10:04:45 +08:00
if (!ok)
2022-07-20 18:41:33 +08:00
{
stack->removeScriptHandler(handler);
2019-11-23 20:27:39 +08:00
return 0;
2022-07-20 18:41:33 +08:00
}
2019-11-23 20:27:39 +08:00
cobj->queryRect(arg0, arg1, nullptr);
2022-07-20 18:41:33 +08:00
stack->removeScriptHandler(handler);
2019-11-23 20:27:39 +08:00
lua_settop(tolua_S, 1);
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "queryRect", argc, 3);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsWorld_queryRect'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsWorld_queryPoint(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
int argc = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsWorld* cobj = nullptr;
2021-12-25 10:04:45 +08:00
bool ok = true;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.PhysicsWorld", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2022-08-08 18:02:17 +08:00
cobj = (ax::PhysicsWorld*)tolua_tousertype(tolua_S, 1, 0);
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
if (!cobj)
{
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "invalid 'cobj' in function 'axlua_physics_PhysicsWorld_queryPoint'", NULL);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
argc = lua_gettop(tolua_S) - 1;
2019-11-23 20:27:39 +08:00
if (argc == 2)
{
2022-08-08 18:02:17 +08:00
std::function<bool(ax::PhysicsWorld&, ax::PhysicsShape&, void*)> arg0;
ax::Vec2 arg1;
2019-11-23 20:27:39 +08:00
LUA_FUNCTION handler = toluafix_ref_function(tolua_S, 2, 0);
2022-07-20 18:41:33 +08:00
auto stack = LuaEngine::getInstance()->getLuaStack();
2021-12-25 10:04:45 +08:00
do
{
2022-08-08 18:02:17 +08:00
arg0 = [handler,stack](ax::PhysicsWorld& world, ax::PhysicsShape& shape, void* data) -> bool {
2021-12-25 10:04:45 +08:00
auto Ls = stack->getLuaState();
2022-07-12 21:31:54 +08:00
tolua_pushusertype(Ls, (void*)(&world), getLuaTypeName(&world, "ax.PhysicsWorld"));
toluafix_pushusertype_object(Ls, shape._ID, &shape._luaID, (void*)(&shape), "ax.PhysicsShape");
2021-11-15 19:05:08 +08:00
return stack->executeFunctionByHandler(handler, 2);
2019-11-23 20:27:39 +08:00
};
assert(false);
2021-12-25 10:04:45 +08:00
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_vec2(tolua_S, 3, &arg1, "ax.PhysicsWorld:queryPoint");
2021-12-25 10:04:45 +08:00
if (!ok)
2022-07-20 18:41:33 +08:00
{
stack->removeScriptHandler(handler);
2019-11-23 20:27:39 +08:00
return 0;
2022-07-20 18:41:33 +08:00
}
2019-11-23 20:27:39 +08:00
cobj->queryPoint(arg0, arg1, nullptr);
2022-07-20 18:41:33 +08:00
stack->removeScriptHandler(handler);
2019-11-23 20:27:39 +08:00
lua_settop(tolua_S, 1);
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "queryPoint", argc, 3);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsWorld_queryPoint'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsBody_createPolygon(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
int argc = 0;
bool ok = true;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertable(tolua_S, 1, "ax.PhysicsBody", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 1)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0 = nullptr;
2021-12-25 10:04:45 +08:00
int arg1 = 0;
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsBody:createPolygon");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsBody* ret = ax::PhysicsBody::createPolygon(arg0, arg1);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
do
{
2019-11-23 20:27:39 +08:00
if (nullptr != ret)
{
2021-12-25 10:04:45 +08:00
int ID = ret->_ID;
2019-11-23 20:27:39 +08:00
int* luaID = &ret->_luaID;
toluafix_pushusertype_object(tolua_S, ID, luaID, (void*)ret, "ax.PhysicsBody");
2019-11-23 20:27:39 +08:00
}
else
{
lua_pushnil(tolua_S);
}
} while (0);
return 1;
}
if (argc == 2)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsBody:createPolygon");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsBody:createPolygon");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsBody* ret = ax::PhysicsBody::createPolygon(arg0, arg1, arg2);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
do
{
2019-11-23 20:27:39 +08:00
if (nullptr != ret)
{
2021-12-25 10:04:45 +08:00
int ID = ret->_ID;
2019-11-23 20:27:39 +08:00
int* luaID = &ret->_luaID;
toluafix_pushusertype_object(tolua_S, ID, luaID, (void*)ret, "ax.PhysicsBody");
2019-11-23 20:27:39 +08:00
}
else
{
lua_pushnil(tolua_S);
}
} while (0);
return 1;
}
if (argc == 3)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
ax::Vec2 arg3;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsBody:createPolygon");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsBody:createPolygon");
ok &= luaval_to_vec2(tolua_S, 4, &arg3, "ax.PhysicsBody:createPolygon");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsBody* ret = ax::PhysicsBody::createPolygon(arg0, arg1, arg2, arg3);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
do
{
2019-11-23 20:27:39 +08:00
if (nullptr != ret)
{
2021-12-25 10:04:45 +08:00
int ID = ret->_ID;
2019-11-23 20:27:39 +08:00
int* luaID = &ret->_luaID;
toluafix_pushusertype_object(tolua_S, ID, luaID, (void*)ret, "ax.PhysicsBody");
2019-11-23 20:27:39 +08:00
}
else
{
lua_pushnil(tolua_S);
}
} while (0);
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "createPolygon", argc, 2);
2019-11-23 20:27:39 +08:00
return 0;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsBody_createPolygon'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsBody_createEdgePolygon(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
int argc = 0;
bool ok = true;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertable(tolua_S, 1, "ax.PhysicsBody", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 1)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsBody:createEdgePolygon");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsBody* ret = ax::PhysicsBody::createEdgePolygon(arg0, arg1);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
do
{
if (nullptr != ret)
{
int ID = ret->_ID;
int* luaID = &ret->_luaID;
toluafix_pushusertype_object(tolua_S, ID, luaID, (void*)ret, "ax.PhysicsBody");
2021-12-25 10:04:45 +08:00
}
else
{
lua_pushnil(tolua_S);
}
2019-11-23 20:27:39 +08:00
} while (0);
return 1;
}
if (argc == 2)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsBody:createEdgePolygon");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsBody:createEdgePolygon");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsBody* ret = ax::PhysicsBody::createEdgePolygon(arg0, arg1, arg2);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
do
{
if (nullptr != ret)
{
int ID = ret->_ID;
int* luaID = &ret->_luaID;
toluafix_pushusertype_object(tolua_S, ID, luaID, (void*)ret, "ax.PhysicsBody");
2021-12-25 10:04:45 +08:00
}
else
{
lua_pushnil(tolua_S);
}
2019-11-23 20:27:39 +08:00
} while (0);
return 1;
}
if (argc == 3)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
2019-11-23 20:27:39 +08:00
double arg3;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsBody:createEdgePolygon");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsBody:createEdgePolygon");
ok &= luaval_to_number(tolua_S, 4, &arg3, "ax.PhysicsBody:createEdgePolygon");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsBody* ret = ax::PhysicsBody::createEdgePolygon(arg0, arg1, arg2, arg3);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
do
{
if (nullptr != ret)
{
int ID = ret->_ID;
int* luaID = &ret->_luaID;
toluafix_pushusertype_object(tolua_S, ID, luaID, (void*)ret, "ax.PhysicsBody");
2021-12-25 10:04:45 +08:00
}
else
{
lua_pushnil(tolua_S);
}
2019-11-23 20:27:39 +08:00
} while (0);
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "createEdgePolygon", argc, 2);
2019-11-23 20:27:39 +08:00
return 0;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsBody_createEdgePolygon'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsBody_createEdgeChain(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
int argc = 0;
bool ok = true;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertable(tolua_S, 1, "ax.PhysicsBody", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 1)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsBody:createEdgeChain");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsBody* ret = ax::PhysicsBody::createEdgeChain(arg0, arg1);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
do
{
2019-11-23 20:27:39 +08:00
if (nullptr != ret)
{
2021-12-25 10:04:45 +08:00
int ID = ret->_ID;
2019-11-23 20:27:39 +08:00
int* luaID = &ret->_luaID;
toluafix_pushusertype_object(tolua_S, ID, luaID, (void*)ret, "ax.PhysicsBody");
2019-11-23 20:27:39 +08:00
}
else
{
lua_pushnil(tolua_S);
}
} while (0);
return 1;
}
if (argc == 2)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsBody:createEdgeChain");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsBody:createEdgeChain");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsBody* ret = ax::PhysicsBody::createEdgeChain(arg0, arg1, arg2);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
do
{
2019-11-23 20:27:39 +08:00
if (nullptr != ret)
{
2021-12-25 10:04:45 +08:00
int ID = ret->_ID;
2019-11-23 20:27:39 +08:00
int* luaID = &ret->_luaID;
toluafix_pushusertype_object(tolua_S, ID, luaID, (void*)ret, "ax.PhysicsBody");
2019-11-23 20:27:39 +08:00
}
else
{
lua_pushnil(tolua_S);
}
} while (0);
return 1;
}
if (argc == 3)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
2019-11-23 20:27:39 +08:00
double arg3;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsBody:createEdgeChain");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsBody:createEdgeChain");
ok &= luaval_to_number(tolua_S, 4, &arg3, "ax.PhysicsBody:createEdgeChain");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsBody* ret = ax::PhysicsBody::createEdgeChain(arg0, arg1, arg2, arg3);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
do
{
2019-11-23 20:27:39 +08:00
if (nullptr != ret)
{
2021-12-25 10:04:45 +08:00
int ID = ret->_ID;
2019-11-23 20:27:39 +08:00
int* luaID = &ret->_luaID;
toluafix_pushusertype_object(tolua_S, ID, luaID, (void*)ret, "ax.PhysicsBody");
2019-11-23 20:27:39 +08:00
}
else
{
lua_pushnil(tolua_S);
}
} while (0);
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "createEdgeChain", argc, 2);
2019-11-23 20:27:39 +08:00
return 0;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsBody_createEdgeChain'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShape_recenterPoints(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
int argc = 0;
bool ok = true;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertable(tolua_S, 1, "ax.PhysicsShape", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 1)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShape:recenterPoints");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShape::recenterPoints(arg0, arg1);
2019-11-23 20:27:39 +08:00
vec2_array_to_luaval(tolua_S, arg0, arg1);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
return 1;
}
if (argc == 2)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2022-08-08 18:02:17 +08:00
ax::Vec2 arg2;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShape:recenterPoints");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_vec2(tolua_S, 3, &arg2, "ax.PhysicsShape:recenterPoints");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShape::recenterPoints(arg0, arg1, arg2);
2019-11-23 20:27:39 +08:00
vec2_array_to_luaval(tolua_S, arg0, arg1);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "recenterPoints", argc, 2);
2019-11-23 20:27:39 +08:00
return 0;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShape_recenterPoints'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShape_getPolygonCenter(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
int argc = 0;
bool ok = true;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertable(tolua_S, 1, "ax.PhysicsShape", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 1)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShape:getPolygonCenter");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::Vec2 ret = ax::PhysicsShape::getPolygonCenter(arg0, arg1);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
vec2_to_luaval(tolua_S, ret);
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "getPolygonCenter", argc, 2);
2019-11-23 20:27:39 +08:00
return 0;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShape_getPolygonCenter'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShapeBox_getPoints(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
int argc = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsShapeBox* cobj = nullptr;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.PhysicsShapeBox", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2022-08-08 18:02:17 +08:00
cobj = (ax::PhysicsShapeBox*)tolua_tousertype(tolua_S, 1, 0);
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
if (!cobj)
{
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "invalid 'cobj' in function 'axlua_physics_PhysicsShapeBox_getPoints'", NULL);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
argc = lua_gettop(tolua_S) - 1;
2019-11-23 20:27:39 +08:00
if (argc == 0)
{
2022-08-08 18:02:17 +08:00
ax::Vec2 arg0[4];
2019-11-23 20:27:39 +08:00
cobj->getPoints(arg0);
vec2_array_to_luaval(tolua_S, arg0, 4);
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "getPoints", argc, 1);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShapeBox_getPoints'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShapePolygon_getPoints(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
int argc = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsShapePolygon* cobj = nullptr;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.PhysicsShapePolygon", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2022-08-08 18:02:17 +08:00
cobj = (ax::PhysicsShapePolygon*)tolua_tousertype(tolua_S, 1, 0);
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
if (!cobj)
{
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "invalid 'cobj' in function 'axlua_physics_PhysicsShapePolygon_getPoints'", NULL);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
argc = lua_gettop(tolua_S) - 1;
2019-11-23 20:27:39 +08:00
if (argc == 0)
{
2021-12-25 10:04:45 +08:00
int count = cobj->getPointsCount();
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0 = new ax::Vec2[count];
2019-11-23 20:27:39 +08:00
cobj->getPoints(arg0);
vec2_array_to_luaval(tolua_S, arg0, count);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "getPoints", argc, 1);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShapePolygon_getPoints'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShapePolygon_create(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
int argc = 0;
bool ok = true;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertable(tolua_S, 1, "ax.PhysicsShapePolygon", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 1)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShapePolygon:create");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShapePolygon* ret = ax::PhysicsShapePolygon::create(arg0, arg1);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2022-08-08 18:02:17 +08:00
object_to_luaval<ax::PhysicsShapePolygon>(tolua_S, "ax.PhysicsShapePolygon",
(ax::PhysicsShapePolygon*)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
if (argc == 2)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShapePolygon:create");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsShapePolygon:create");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShapePolygon* ret = ax::PhysicsShapePolygon::create(arg0, arg1, arg2);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2022-08-08 18:02:17 +08:00
object_to_luaval<ax::PhysicsShapePolygon>(tolua_S, "ax.PhysicsShapePolygon",
(ax::PhysicsShapePolygon*)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
if (argc == 3)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
ax::Vec2 arg3;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShapePolygon:create");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsShapePolygon:create");
ok &= luaval_to_vec2(tolua_S, 4, &arg3, "ax.PhysicsShapePolygon:create");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShapePolygon* ret = ax::PhysicsShapePolygon::create(arg0, arg1, arg2, arg3);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2022-08-08 18:02:17 +08:00
object_to_luaval<ax::PhysicsShapePolygon>(tolua_S, "ax.PhysicsShapePolygon",
(ax::PhysicsShapePolygon*)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "create", argc, 2);
2019-11-23 20:27:39 +08:00
return 0;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShapePolygon_create'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShapePolygon_calculateArea(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
int argc = 0;
bool ok = true;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertable(tolua_S, 1, "ax.PhysicsShapePolygon", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 1)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShapePolygon:calculateArea");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
double ret = ax::PhysicsShapePolygon::calculateArea(arg0, arg1);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2021-12-25 10:04:45 +08:00
tolua_pushnumber(tolua_S, (lua_Number)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "calculateArea", argc, 2);
2019-11-23 20:27:39 +08:00
return 0;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShapePolygon_calculateArea'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShapePolygon_calculateMoment(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
int argc = 0;
bool ok = true;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertable(tolua_S, 1, "ax.PhysicsShapePolygon", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 2)
{
double arg0;
2022-08-08 18:02:17 +08:00
ax::Vec2* arg1;
2019-11-23 20:27:39 +08:00
int arg2 = 0;
2022-07-12 21:31:54 +08:00
ok &= luaval_to_number(tolua_S, 2, &arg0, "ax.PhysicsShapePolygon:calculateMoment");
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 3, &arg1, &arg2, "ax.PhysicsShapePolygon:calculateMoment");
2021-12-25 10:04:45 +08:00
if (nullptr == arg1)
{
LUA_PRECONDITION(arg1, "Invalid Native Object");
}
} while (0);
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg1);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
double ret = ax::PhysicsShapePolygon::calculateMoment(arg0, arg1, arg2);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg1);
2021-12-25 10:04:45 +08:00
tolua_pushnumber(tolua_S, (lua_Number)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
if (argc == 2)
{
double arg0;
2022-08-08 18:02:17 +08:00
ax::Vec2* arg1;
2019-11-23 20:27:39 +08:00
int arg2 = 0;
2022-08-08 18:02:17 +08:00
ax::Vec2 arg3;
2022-07-12 21:31:54 +08:00
ok &= luaval_to_number(tolua_S, 2, &arg0, "ax.PhysicsShapePolygon:calculateMoment");
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 3, &arg1, &arg2, "ax.PhysicsShapePolygon:calculateMoment");
2021-12-25 10:04:45 +08:00
if (nullptr == arg1)
{
LUA_PRECONDITION(arg1, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_vec2(tolua_S, 4, &arg3, "ax.PhysicsShapePolygon:calculateMoment");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg1);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
double ret = ax::PhysicsShapePolygon::calculateMoment(arg0, arg1, arg2, arg3);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg1);
2021-12-25 10:04:45 +08:00
tolua_pushnumber(tolua_S, (lua_Number)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "calculateMoment", argc, 3);
2019-11-23 20:27:39 +08:00
return 0;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShapePolygon_calculateMoment'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShapeEdgeBox_getPoints(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
int argc = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsShapeEdgeBox* cobj = nullptr;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.PhysicsShapeEdgeBox", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2022-08-08 18:02:17 +08:00
cobj = (ax::PhysicsShapeEdgeBox*)tolua_tousertype(tolua_S, 1, 0);
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
if (!cobj)
{
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "invalid 'cobj' in function 'axlua_physics_PhysicsShapeEdgeBox_getPoints'", NULL);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
argc = lua_gettop(tolua_S) - 1;
2019-11-23 20:27:39 +08:00
if (argc == 0)
{
2021-12-25 10:04:45 +08:00
int count = cobj->getPointsCount();
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0 = new ax::Vec2[count];
2019-11-23 20:27:39 +08:00
cobj->getPoints(arg0);
vec2_array_to_luaval(tolua_S, arg0, count);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "getPoints", argc, 1);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShapeEdgeBox_getPoints'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShapeEdgePolygon_getPoints(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
int argc = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsShapeEdgePolygon* cobj = nullptr;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.PhysicsShapeEdgePolygon", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2022-08-08 18:02:17 +08:00
cobj = (ax::PhysicsShapeEdgePolygon*)tolua_tousertype(tolua_S, 1, 0);
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
if (!cobj)
{
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "invalid 'cobj' in function 'axlua_physics_PhysicsShapeEdgePolygon_getPoints'",
2021-12-25 10:04:45 +08:00
NULL);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
argc = lua_gettop(tolua_S) - 1;
2019-11-23 20:27:39 +08:00
if (argc == 0)
{
2021-12-25 10:04:45 +08:00
int count = cobj->getPointsCount();
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0 = new ax::Vec2[count];
2019-11-23 20:27:39 +08:00
cobj->getPoints(arg0);
vec2_array_to_luaval(tolua_S, arg0, count);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "getPoints", argc, 1);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShapeEdgePolygon_getPoints'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShapeEdgeChain_getPoints(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
int argc = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsShapeEdgeChain* cobj = nullptr;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.PhysicsShapeEdgeChain", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2022-08-08 18:02:17 +08:00
cobj = (ax::PhysicsShapeEdgeChain*)tolua_tousertype(tolua_S, 1, 0);
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
if (!cobj)
{
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "invalid 'cobj' in function 'axlua_physics_PhysicsShapeEdgeChain_getPoints'", NULL);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
argc = lua_gettop(tolua_S) - 1;
2019-11-23 20:27:39 +08:00
if (argc == 0)
{
2021-12-25 10:04:45 +08:00
int count = cobj->getPointsCount();
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0 = new ax::Vec2[count];
2019-11-23 20:27:39 +08:00
cobj->getPoints(arg0);
vec2_array_to_luaval(tolua_S, arg0, count);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "getPoints", argc, 1);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShapeEdgeChain_getPoints'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
static int toaxlua_EventListenerPhysicsContact_registerScriptHandler(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
if (nullptr == tolua_S)
return 0;
2021-12-25 10:04:45 +08:00
int argc = 0;
2019-11-23 20:27:39 +08:00
EventListenerPhysicsContact* self = nullptr;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2022-07-12 21:31:54 +08:00
if (!tolua_isusertype(tolua_S, 1, "ax.EventListenerPhysicsContact", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
self = static_cast<EventListenerPhysicsContact*>(tolua_tousertype(tolua_S, 1, 0));
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2021-12-25 10:04:45 +08:00
if (nullptr == self)
{
tolua_error(tolua_S,
2022-08-08 18:02:17 +08:00
"invalid 'self' in function 'toaxlua_EventListenerPhysicsContact_registerScriptHandler'\n",
2021-12-25 10:04:45 +08:00
nullptr);
2019-11-23 20:27:39 +08:00
return 0;
}
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 2)
{
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2021-12-25 10:04:45 +08:00
if (!toluafix_isfunction(tolua_S, 2, "LUA_FUNCTION", 0, &tolua_err) ||
2019-11-23 20:27:39 +08:00
!tolua_isnumber(tolua_S, 3, 0, &tolua_err))
{
goto tolua_lerror;
}
2021-12-25 10:04:45 +08:00
# endif
LUA_FUNCTION handler = toluafix_ref_function(tolua_S, 2, 0);
ScriptHandlerMgr::HandlerType type =
static_cast<ScriptHandlerMgr::HandlerType>((int)tolua_tonumber(tolua_S, 3, 0));
2019-11-23 20:27:39 +08:00
switch (type)
{
2021-12-25 10:04:45 +08:00
case ScriptHandlerMgr::HandlerType::EVENT_PHYSICS_CONTACT_BEGIN:
{
ScriptHandlerMgr::getInstance()->addObjectHandler((void*)self, handler, type);
self->onContactBegin = [handler](PhysicsContact& contact) -> bool {
LuaStack* stack = LuaEngine::getInstance()->getLuaStack();
2022-07-12 21:31:54 +08:00
stack->pushObject(&contact, "ax.PhysicsContact");
2021-12-25 10:04:45 +08:00
bool ret = stack->executeFunctionByHandler(handler, 1);
stack->clean();
return ret;
};
}
break;
case ScriptHandlerMgr::HandlerType::EVENT_PHYSICS_CONTACT_PRESOLVE:
{
ScriptHandlerMgr::getInstance()->addObjectHandler((void*)self, handler, type);
self->onContactPreSolve = [handler](PhysicsContact& contact, PhysicsContactPreSolve& solve) -> bool {
LuaStack* stack = LuaEngine::getInstance()->getLuaStack();
2022-07-12 21:31:54 +08:00
stack->pushObject(&contact, "ax.PhysicsContact");
tolua_pushusertype(stack->getLuaState(), &solve, "ax.PhysicsContactPreSolve");
2021-12-25 10:04:45 +08:00
bool ret = stack->executeFunctionByHandler(handler, 2);
stack->clean();
return ret;
};
}
break;
case ScriptHandlerMgr::HandlerType::EVENT_PHYSICS_CONTACT_POSTSOLVE:
{
ScriptHandlerMgr::getInstance()->addObjectHandler((void*)self, handler, type);
self->onContactPostSolve = [handler](PhysicsContact& contact, const PhysicsContactPostSolve& solve) {
LuaStack* stack = LuaEngine::getInstance()->getLuaStack();
2022-07-12 21:31:54 +08:00
stack->pushObject(&contact, "ax.PhysicsContact");
2021-12-25 10:04:45 +08:00
tolua_pushusertype(stack->getLuaState(), const_cast<PhysicsContactPostSolve*>(&solve),
2022-07-12 21:31:54 +08:00
"ax.PhysicsContactPostSolve");
2021-12-25 10:04:45 +08:00
stack->executeFunctionByHandler(handler, 2);
stack->clean();
};
}
break;
case ScriptHandlerMgr::HandlerType::EVENT_PHYSICS_CONTACT_SEPARATE:
{
ScriptHandlerMgr::getInstance()->addObjectHandler((void*)self, handler, type);
self->onContactSeparate = [handler](PhysicsContact& contact) {
LuaStack* stack = LuaEngine::getInstance()->getLuaStack();
2022-07-12 21:31:54 +08:00
stack->pushObject(&contact, "ax.PhysicsContact");
2021-12-25 10:04:45 +08:00
stack->executeFunctionByHandler(handler, 1);
stack->clean();
};
}
break;
default:
break;
2019-11-23 20:27:39 +08:00
}
return 0;
}
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
luaL_error(tolua_S, "'registerScriptHandler' has wrong number of arguments: %d, was expecting %d\n", argc, 2);
return 0;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2021-12-25 10:04:45 +08:00
tolua_error(tolua_S, "#ferror in function 'registerScriptHandler'.", &tolua_err);
2019-11-23 20:27:39 +08:00
return 0;
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShapeEdgePolygon_create(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
int argc = 0;
bool ok = true;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertable(tolua_S, 1, "ax.PhysicsShapeEdgePolygon", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 1)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShapeEdgePolygon:create");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShapeEdgePolygon* ret = ax::PhysicsShapeEdgePolygon::create(arg0, arg1);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2022-08-08 18:02:17 +08:00
object_to_luaval<ax::PhysicsShapeEdgePolygon>(tolua_S, "ax.PhysicsShapeEdgePolygon",
(ax::PhysicsShapeEdgePolygon*)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
if (argc == 2)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShapeEdgePolygon:create");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsShapeEdgePolygon:create");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShapeEdgePolygon* ret = ax::PhysicsShapeEdgePolygon::create(arg0, arg1, arg2);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2022-08-08 18:02:17 +08:00
object_to_luaval<ax::PhysicsShapeEdgePolygon>(tolua_S, "ax.PhysicsShapeEdgePolygon",
(ax::PhysicsShapeEdgePolygon*)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
if (argc == 3)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
2019-11-23 20:27:39 +08:00
double arg3;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShapeEdgePolygon:create");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsShapeEdgePolygon:create");
ok &= luaval_to_number(tolua_S, 4, &arg3, "ax.PhysicsShapeEdgePolygon:create");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShapeEdgePolygon* ret = ax::PhysicsShapeEdgePolygon::create(arg0, arg1, arg2, arg3);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2022-08-08 18:02:17 +08:00
object_to_luaval<ax::PhysicsShapeEdgePolygon>(tolua_S, "ax.PhysicsShapeEdgePolygon",
(ax::PhysicsShapeEdgePolygon*)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "create", argc, 2);
2019-11-23 20:27:39 +08:00
return 0;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShapeEdgePolygon_create'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
int axlua_physics_PhysicsShapeEdgeChain_create(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
int argc = 0;
bool ok = true;
2021-12-25 10:04:45 +08:00
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_Error tolua_err;
2021-12-25 10:04:45 +08:00
# endif
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2022-07-12 21:31:54 +08:00
if (!tolua_isusertable(tolua_S, 1, "ax.PhysicsShapeEdgeChain", 0, &tolua_err))
2021-12-25 10:04:45 +08:00
goto tolua_lerror;
# endif
2019-11-23 20:27:39 +08:00
argc = lua_gettop(tolua_S) - 1;
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
if (argc == 1)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShapeEdgeChain:create");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShapeEdgeChain* ret = ax::PhysicsShapeEdgeChain::create(arg0, arg1);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2022-08-08 18:02:17 +08:00
object_to_luaval<ax::PhysicsShapeEdgeChain>(tolua_S, "ax.PhysicsShapeEdgeChain",
(ax::PhysicsShapeEdgeChain*)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
if (argc == 2)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShapeEdgeChain:create");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsShapeEdgeChain:create");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShapeEdgeChain* ret = ax::PhysicsShapeEdgeChain::create(arg0, arg1, arg2);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2022-08-08 18:02:17 +08:00
object_to_luaval<ax::PhysicsShapeEdgeChain>(tolua_S, "ax.PhysicsShapeEdgeChain",
(ax::PhysicsShapeEdgeChain*)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
if (argc == 3)
{
2022-08-08 18:02:17 +08:00
ax::Vec2* arg0;
2019-11-23 20:27:39 +08:00
int arg1 = 0;
2022-08-08 18:02:17 +08:00
ax::PhysicsMaterial arg2;
2019-11-23 20:27:39 +08:00
double arg3;
2021-12-25 10:04:45 +08:00
do
{
2022-07-12 21:31:54 +08:00
ok = luaval_to_array_of_vec2(tolua_S, 2, &arg0, &arg1, "ax.PhysicsShapeEdgeChain:create");
2021-12-25 10:04:45 +08:00
if (nullptr == arg0)
{
LUA_PRECONDITION(arg0, "Invalid Native Object");
}
} while (0);
2022-07-12 21:31:54 +08:00
ok &= luaval_to_physics_material(tolua_S, 3, &arg2, "ax.PhysicsShapeEdgeChain:create");
ok &= luaval_to_number(tolua_S, 4, &arg3, "ax.PhysicsShapeEdgeChain:create");
2021-12-25 10:04:45 +08:00
if (!ok)
2019-11-23 20:27:39 +08:00
{
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2019-11-23 20:27:39 +08:00
return 0;
}
2022-08-08 18:02:17 +08:00
ax::PhysicsShapeEdgeChain* ret = ax::PhysicsShapeEdgeChain::create(arg0, arg1, arg2, arg3);
2022-07-16 10:43:05 +08:00
AX_SAFE_DELETE_ARRAY(arg0);
2022-08-08 18:02:17 +08:00
object_to_luaval<ax::PhysicsShapeEdgeChain>(tolua_S, "ax.PhysicsShapeEdgeChain",
(ax::PhysicsShapeEdgeChain*)ret);
2019-11-23 20:27:39 +08:00
return 1;
}
2021-12-25 10:04:45 +08:00
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d\n ", "create", argc, 2);
2019-11-23 20:27:39 +08:00
return 0;
2022-08-08 18:02:17 +08:00
# if _AX_DEBUG >= 1
2019-11-23 20:27:39 +08:00
tolua_lerror:
2022-08-08 18:02:17 +08:00
tolua_error(tolua_S, "#ferror in function 'axlua_physics_PhysicsShapeEdgeChain_create'.", &tolua_err);
2021-12-25 10:04:45 +08:00
# endif
2019-11-23 20:27:39 +08:00
return 0;
}
int register_all_ax_physics_manual(lua_State* tolua_S)
2019-11-23 20:27:39 +08:00
{
2022-07-12 21:31:54 +08:00
lua_pushstring(tolua_S, "ax.PhysicsBody");
2019-11-23 20:27:39 +08:00
lua_rawget(tolua_S, LUA_REGISTRYINDEX);
2021-12-25 10:04:45 +08:00
if (lua_istable(tolua_S, -1))
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
lua_pushstring(tolua_S, "getJoints");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsBody_getJoints);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "createPolygon");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsBody_createPolygon);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "createEdgeChain");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsBody_createEdgeChain);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "createEdgePolygon");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsBody_createEdgePolygon);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
}
lua_pop(tolua_S, 1);
2021-12-25 10:04:45 +08:00
2022-07-12 21:31:54 +08:00
lua_pushstring(tolua_S, "ax.PhysicsShape");
2019-11-23 20:27:39 +08:00
lua_rawget(tolua_S, LUA_REGISTRYINDEX);
2021-12-25 10:04:45 +08:00
if (lua_istable(tolua_S, -1))
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
lua_pushstring(tolua_S, "recenterPoints");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShape_recenterPoints);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "getPolygonCenter");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShape_getPolygonCenter);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "getPolyonCenter");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShape_getPolygonCenter);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
}
lua_pop(tolua_S, 1);
2021-12-25 10:04:45 +08:00
2022-07-12 21:31:54 +08:00
lua_pushstring(tolua_S, "ax.PhysicsShapeBox");
2019-11-23 20:27:39 +08:00
lua_rawget(tolua_S, LUA_REGISTRYINDEX);
2021-12-25 10:04:45 +08:00
if (lua_istable(tolua_S, -1))
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
lua_pushstring(tolua_S, "getPoints");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShapeBox_getPoints);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
}
lua_pop(tolua_S, 1);
2021-12-25 10:04:45 +08:00
2022-07-12 21:31:54 +08:00
lua_pushstring(tolua_S, "ax.PhysicsShapeEdgeBox");
2019-11-23 20:27:39 +08:00
lua_rawget(tolua_S, LUA_REGISTRYINDEX);
2021-12-25 10:04:45 +08:00
if (lua_istable(tolua_S, -1))
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
lua_pushstring(tolua_S, "getPoints");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShapeEdgeBox_getPoints);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
}
lua_pop(tolua_S, 1);
2021-12-25 10:04:45 +08:00
2022-07-12 21:31:54 +08:00
lua_pushstring(tolua_S, "ax.PhysicsShapePolygon");
2019-11-23 20:27:39 +08:00
lua_rawget(tolua_S, LUA_REGISTRYINDEX);
2021-12-25 10:04:45 +08:00
if (lua_istable(tolua_S, -1))
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
lua_pushstring(tolua_S, "getPoints");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShapePolygon_getPoints);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "create");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShapePolygon_create);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "calculateArea");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShapePolygon_calculateArea);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "calculateMoment");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShapePolygon_calculateMoment);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
}
lua_pop(tolua_S, 1);
2021-12-25 10:04:45 +08:00
2022-07-12 21:31:54 +08:00
lua_pushstring(tolua_S, "ax.PhysicsShapeEdgePolygon");
2019-11-23 20:27:39 +08:00
lua_rawget(tolua_S, LUA_REGISTRYINDEX);
2021-12-25 10:04:45 +08:00
if (lua_istable(tolua_S, -1))
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
lua_pushstring(tolua_S, "getPoints");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShapeEdgePolygon_getPoints);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "create");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShapeEdgePolygon_create);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
}
lua_pop(tolua_S, 1);
2021-12-25 10:04:45 +08:00
2022-07-12 21:31:54 +08:00
lua_pushstring(tolua_S, "ax.PhysicsShapeEdgeChain");
2019-11-23 20:27:39 +08:00
lua_rawget(tolua_S, LUA_REGISTRYINDEX);
2021-12-25 10:04:45 +08:00
if (lua_istable(tolua_S, -1))
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
lua_pushstring(tolua_S, "getPoints");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShapeEdgeChain_getPoints);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "create");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsShapeEdgeChain_create);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
}
lua_pop(tolua_S, 1);
2021-12-25 10:04:45 +08:00
2022-07-12 21:31:54 +08:00
lua_pushstring(tolua_S, "ax.PhysicsWorld");
2019-11-23 20:27:39 +08:00
lua_rawget(tolua_S, LUA_REGISTRYINDEX);
2021-12-25 10:04:45 +08:00
if (lua_istable(tolua_S, -1))
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
lua_pushstring(tolua_S, "getScene");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsWorld_getScene);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "queryPoint");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsWorld_queryPoint);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "queryRect");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsWorld_queryRect);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
lua_pushstring(tolua_S, "rayCast");
2022-08-08 18:02:17 +08:00
lua_pushcfunction(tolua_S, axlua_physics_PhysicsWorld_rayCast);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
lua_pushstring(tolua_S, "DEBUGDRAW_NONE");
lua_pushnumber(tolua_S, PhysicsWorld::DEBUGDRAW_NONE);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
lua_pushstring(tolua_S, "DEBUGDRAW_SHAPE");
lua_pushnumber(tolua_S, PhysicsWorld::DEBUGDRAW_SHAPE);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
lua_pushstring(tolua_S, "DEBUGDRAW_JOINT");
lua_pushnumber(tolua_S, PhysicsWorld::DEBUGDRAW_JOINT);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
lua_pushstring(tolua_S, "DEBUGDRAW_CONTACT");
lua_pushnumber(tolua_S, PhysicsWorld::DEBUGDRAW_CONTACT);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
lua_pushstring(tolua_S, "DEBUGDRAW_ALL");
lua_pushnumber(tolua_S, PhysicsWorld::DEBUGDRAW_ALL);
2021-12-25 10:04:45 +08:00
lua_rawset(tolua_S, -3);
2019-11-23 20:27:39 +08:00
}
lua_pop(tolua_S, 1);
2021-12-25 10:04:45 +08:00
2022-07-12 21:31:54 +08:00
lua_pushstring(tolua_S, "ax.EventListenerPhysicsContact");
2019-11-23 20:27:39 +08:00
lua_rawget(tolua_S, LUA_REGISTRYINDEX);
2021-12-25 10:04:45 +08:00
if (lua_istable(tolua_S, -1))
2019-11-23 20:27:39 +08:00
{
2021-12-25 10:04:45 +08:00
tolua_function(tolua_S, "registerScriptHandler",
2022-08-08 18:02:17 +08:00
toaxlua_EventListenerPhysicsContact_registerScriptHandler);
2019-11-23 20:27:39 +08:00
}
lua_pop(tolua_S, 1);
tolua_constant(tolua_S, "PHYSICS_INFINITY", PHYSICS_INFINITY);
2021-12-25 10:04:45 +08:00
2019-11-23 20:27:39 +08:00
return 0;
}
#endif