Files
cocos4/native/cocos/bindings/auto/jsb_physics_auto.cpp
T

4972 lines
202 KiB
C++

// clang-format off
#include "cocos/bindings/auto/jsb_physics_auto.h"
#include "cocos/bindings/manual/jsb_conversions.h"
#include "cocos/bindings/manual/jsb_global.h"
#include "physics/PhysicsSDK.h"
#ifndef JSB_ALLOC
#define JSB_ALLOC(kls, ...) new (std::nothrow) kls(__VA_ARGS__)
#endif
#ifndef JSB_FREE
#define JSB_FREE(ptr) delete ptr
#endif
#if CC_DEBUG
static bool js_physics_getter_return_true(se::State& s) // NOLINT(readability-identifier-naming)
{
s.rval().setBoolean(true);
return true;
}
SE_BIND_PROP_GET(js_physics_getter_return_true)
#endif
se::Object* __jsb_cc_physics_RevoluteJoint_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_RevoluteJoint_class = nullptr; // NOLINT
static bool js_physics_RevoluteJoint_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RevoluteJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RevoluteJoint_getObjectID)
static bool js_physics_RevoluteJoint_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RevoluteJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::Node*, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RevoluteJoint_initialize)
static bool js_physics_RevoluteJoint_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RevoluteJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RevoluteJoint_onDestroy)
static bool js_physics_RevoluteJoint_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RevoluteJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RevoluteJoint_onDisable)
static bool js_physics_RevoluteJoint_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RevoluteJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RevoluteJoint_onEnable)
static bool js_physics_RevoluteJoint_setAxis(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RevoluteJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAxis(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_RevoluteJoint_setAxis)
static bool js_physics_RevoluteJoint_setConnectedBody(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RevoluteJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setConnectedBody(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RevoluteJoint_setConnectedBody)
static bool js_physics_RevoluteJoint_setEnableCollision(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RevoluteJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setEnableCollision(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RevoluteJoint_setEnableCollision)
static bool js_physics_RevoluteJoint_setPivotA(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RevoluteJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setPivotA(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_RevoluteJoint_setPivotA)
static bool js_physics_RevoluteJoint_setPivotB(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RevoluteJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setPivotB(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_RevoluteJoint_setPivotB)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_RevoluteJoint_finalize)
static bool js_physics_RevoluteJoint_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::RevoluteJoint);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_RevoluteJoint_constructor, __jsb_cc_physics_RevoluteJoint_class, js_cc_physics_RevoluteJoint_finalize)
static bool js_cc_physics_RevoluteJoint_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_RevoluteJoint_finalize)
bool js_register_physics_RevoluteJoint(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("RevoluteJoint", obj, nullptr, _SE(js_physics_RevoluteJoint_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("getObjectID", _SE(js_physics_RevoluteJoint_getObjectID));
cls->defineFunction("initialize", _SE(js_physics_RevoluteJoint_initialize));
cls->defineFunction("onDestroy", _SE(js_physics_RevoluteJoint_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_RevoluteJoint_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_RevoluteJoint_onEnable));
cls->defineFunction("setAxis", _SE(js_physics_RevoluteJoint_setAxis));
cls->defineFunction("setConnectedBody", _SE(js_physics_RevoluteJoint_setConnectedBody));
cls->defineFunction("setEnableCollision", _SE(js_physics_RevoluteJoint_setEnableCollision));
cls->defineFunction("setPivotA", _SE(js_physics_RevoluteJoint_setPivotA));
cls->defineFunction("setPivotB", _SE(js_physics_RevoluteJoint_setPivotB));
cls->defineFinalizeFunction(_SE(js_cc_physics_RevoluteJoint_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::RevoluteJoint>(cls);
__jsb_cc_physics_RevoluteJoint_proto = cls->getProto();
__jsb_cc_physics_RevoluteJoint_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_DistanceJoint_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_DistanceJoint_class = nullptr; // NOLINT
static bool js_physics_DistanceJoint_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::DistanceJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_DistanceJoint_getObjectID)
static bool js_physics_DistanceJoint_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::DistanceJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::Node*, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_DistanceJoint_initialize)
static bool js_physics_DistanceJoint_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::DistanceJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_DistanceJoint_onDestroy)
static bool js_physics_DistanceJoint_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::DistanceJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_DistanceJoint_onDisable)
static bool js_physics_DistanceJoint_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::DistanceJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_DistanceJoint_onEnable)
static bool js_physics_DistanceJoint_setConnectedBody(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::DistanceJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setConnectedBody(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_DistanceJoint_setConnectedBody)
static bool js_physics_DistanceJoint_setEnableCollision(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::DistanceJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setEnableCollision(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_DistanceJoint_setEnableCollision)
static bool js_physics_DistanceJoint_setPivotA(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::DistanceJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setPivotA(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_DistanceJoint_setPivotA)
static bool js_physics_DistanceJoint_setPivotB(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::DistanceJoint>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setPivotB(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_DistanceJoint_setPivotB)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_DistanceJoint_finalize)
static bool js_physics_DistanceJoint_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::DistanceJoint);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_DistanceJoint_constructor, __jsb_cc_physics_DistanceJoint_class, js_cc_physics_DistanceJoint_finalize)
static bool js_cc_physics_DistanceJoint_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_DistanceJoint_finalize)
bool js_register_physics_DistanceJoint(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("DistanceJoint", obj, nullptr, _SE(js_physics_DistanceJoint_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("getObjectID", _SE(js_physics_DistanceJoint_getObjectID));
cls->defineFunction("initialize", _SE(js_physics_DistanceJoint_initialize));
cls->defineFunction("onDestroy", _SE(js_physics_DistanceJoint_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_DistanceJoint_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_DistanceJoint_onEnable));
cls->defineFunction("setConnectedBody", _SE(js_physics_DistanceJoint_setConnectedBody));
cls->defineFunction("setEnableCollision", _SE(js_physics_DistanceJoint_setEnableCollision));
cls->defineFunction("setPivotA", _SE(js_physics_DistanceJoint_setPivotA));
cls->defineFunction("setPivotB", _SE(js_physics_DistanceJoint_setPivotB));
cls->defineFinalizeFunction(_SE(js_cc_physics_DistanceJoint_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::DistanceJoint>(cls);
__jsb_cc_physics_DistanceJoint_proto = cls->getProto();
__jsb_cc_physics_DistanceJoint_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_RigidBody_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_RigidBody_class = nullptr; // NOLINT
static bool js_physics_RigidBody_applyForce(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<float, false> arg4 = {};
HolderType<float, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->applyForce(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_applyForce)
static bool js_physics_RigidBody_applyImpulse(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<float, false> arg4 = {};
HolderType<float, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->applyImpulse(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_applyImpulse)
static bool js_physics_RigidBody_applyLocalForce(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<float, false> arg4 = {};
HolderType<float, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->applyLocalForce(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_applyLocalForce)
static bool js_physics_RigidBody_applyLocalImpulse(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<float, false> arg4 = {};
HolderType<float, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->applyLocalImpulse(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_applyLocalImpulse)
static bool js_physics_RigidBody_applyLocalTorque(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->applyLocalTorque(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_applyLocalTorque)
static bool js_physics_RigidBody_applyTorque(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->applyTorque(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_applyTorque)
static bool js_physics_RigidBody_clearForces(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->clearForces();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_clearForces)
static bool js_physics_RigidBody_clearState(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->clearState();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_clearState)
static bool js_physics_RigidBody_clearVelocity(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->clearVelocity();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_clearVelocity)
static bool js_physics_RigidBody_getAngularVelocity(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::Vec3 result = cobj->getAngularVelocity();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_getAngularVelocity)
static bool js_physics_RigidBody_getGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getGroup();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_getGroup)
static bool js_physics_RigidBody_getLinearVelocity(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::Vec3 result = cobj->getLinearVelocity();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_getLinearVelocity)
static bool js_physics_RigidBody_getMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getMask();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_getMask)
static bool js_physics_RigidBody_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_getObjectID)
static bool js_physics_RigidBody_getSleepThreshold(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
float result = cobj->getSleepThreshold();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_getSleepThreshold)
static bool js_physics_RigidBody_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<cc::Node*, false> arg0 = {};
HolderType<cc::physics::ERigidBodyType, false> arg1 = {};
HolderType<unsigned int, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_initialize)
static bool js_physics_RigidBody_isAwake(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
bool result = cobj->isAwake();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_isAwake)
static bool js_physics_RigidBody_isSleeping(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
bool result = cobj->isSleeping();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_isSleeping)
static bool js_physics_RigidBody_isSleepy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
bool result = cobj->isSleepy();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_isSleepy)
static bool js_physics_RigidBody_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_onDestroy)
static bool js_physics_RigidBody_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_onDisable)
static bool js_physics_RigidBody_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_onEnable)
static bool js_physics_RigidBody_setAllowSleep(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAllowSleep(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setAllowSleep)
static bool js_physics_RigidBody_setAngularDamping(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<float, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAngularDamping(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setAngularDamping)
static bool js_physics_RigidBody_setAngularFactor(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAngularFactor(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setAngularFactor)
static bool js_physics_RigidBody_setAngularVelocity(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAngularVelocity(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setAngularVelocity)
static bool js_physics_RigidBody_setGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setGroup(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setGroup)
static bool js_physics_RigidBody_setLinearDamping(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<float, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setLinearDamping(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setLinearDamping)
static bool js_physics_RigidBody_setLinearFactor(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setLinearFactor(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setLinearFactor)
static bool js_physics_RigidBody_setLinearVelocity(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setLinearVelocity(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setLinearVelocity)
static bool js_physics_RigidBody_setMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMask(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setMask)
static bool js_physics_RigidBody_setMass(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<float, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMass(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setMass)
static bool js_physics_RigidBody_setSleepThreshold(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<float, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setSleepThreshold(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setSleepThreshold)
static bool js_physics_RigidBody_setType(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::ERigidBodyType, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setType(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_setType)
static bool js_physics_RigidBody_sleep(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->sleep();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_sleep)
static bool js_physics_RigidBody_useCCD(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->useCCD(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_useCCD)
static bool js_physics_RigidBody_useGravity(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->useGravity(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_useGravity)
static bool js_physics_RigidBody_wakeUp(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::RigidBody>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->wakeUp();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_RigidBody_wakeUp)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_RigidBody_finalize)
static bool js_physics_RigidBody_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::RigidBody);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_RigidBody_constructor, __jsb_cc_physics_RigidBody_class, js_cc_physics_RigidBody_finalize)
static bool js_cc_physics_RigidBody_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_RigidBody_finalize)
bool js_register_physics_RigidBody(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("RigidBody", obj, nullptr, _SE(js_physics_RigidBody_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("applyForce", _SE(js_physics_RigidBody_applyForce));
cls->defineFunction("applyImpulse", _SE(js_physics_RigidBody_applyImpulse));
cls->defineFunction("applyLocalForce", _SE(js_physics_RigidBody_applyLocalForce));
cls->defineFunction("applyLocalImpulse", _SE(js_physics_RigidBody_applyLocalImpulse));
cls->defineFunction("applyLocalTorque", _SE(js_physics_RigidBody_applyLocalTorque));
cls->defineFunction("applyTorque", _SE(js_physics_RigidBody_applyTorque));
cls->defineFunction("clearForces", _SE(js_physics_RigidBody_clearForces));
cls->defineFunction("clearState", _SE(js_physics_RigidBody_clearState));
cls->defineFunction("clearVelocity", _SE(js_physics_RigidBody_clearVelocity));
cls->defineFunction("getAngularVelocity", _SE(js_physics_RigidBody_getAngularVelocity));
cls->defineFunction("getGroup", _SE(js_physics_RigidBody_getGroup));
cls->defineFunction("getLinearVelocity", _SE(js_physics_RigidBody_getLinearVelocity));
cls->defineFunction("getMask", _SE(js_physics_RigidBody_getMask));
cls->defineFunction("getObjectID", _SE(js_physics_RigidBody_getObjectID));
cls->defineFunction("getSleepThreshold", _SE(js_physics_RigidBody_getSleepThreshold));
cls->defineFunction("initialize", _SE(js_physics_RigidBody_initialize));
cls->defineFunction("isAwake", _SE(js_physics_RigidBody_isAwake));
cls->defineFunction("isSleeping", _SE(js_physics_RigidBody_isSleeping));
cls->defineFunction("isSleepy", _SE(js_physics_RigidBody_isSleepy));
cls->defineFunction("onDestroy", _SE(js_physics_RigidBody_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_RigidBody_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_RigidBody_onEnable));
cls->defineFunction("setAllowSleep", _SE(js_physics_RigidBody_setAllowSleep));
cls->defineFunction("setAngularDamping", _SE(js_physics_RigidBody_setAngularDamping));
cls->defineFunction("setAngularFactor", _SE(js_physics_RigidBody_setAngularFactor));
cls->defineFunction("setAngularVelocity", _SE(js_physics_RigidBody_setAngularVelocity));
cls->defineFunction("setGroup", _SE(js_physics_RigidBody_setGroup));
cls->defineFunction("setLinearDamping", _SE(js_physics_RigidBody_setLinearDamping));
cls->defineFunction("setLinearFactor", _SE(js_physics_RigidBody_setLinearFactor));
cls->defineFunction("setLinearVelocity", _SE(js_physics_RigidBody_setLinearVelocity));
cls->defineFunction("setMask", _SE(js_physics_RigidBody_setMask));
cls->defineFunction("setMass", _SE(js_physics_RigidBody_setMass));
cls->defineFunction("setSleepThreshold", _SE(js_physics_RigidBody_setSleepThreshold));
cls->defineFunction("setType", _SE(js_physics_RigidBody_setType));
cls->defineFunction("sleep", _SE(js_physics_RigidBody_sleep));
cls->defineFunction("useCCD", _SE(js_physics_RigidBody_useCCD));
cls->defineFunction("useGravity", _SE(js_physics_RigidBody_useGravity));
cls->defineFunction("wakeUp", _SE(js_physics_RigidBody_wakeUp));
cls->defineFinalizeFunction(_SE(js_cc_physics_RigidBody_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::RigidBody>(cls);
__jsb_cc_physics_RigidBody_proto = cls->getProto();
__jsb_cc_physics_RigidBody_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_SphereShape_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_SphereShape_class = nullptr; // NOLINT
static bool js_physics_SphereShape_getAABB(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::AABB& result = cobj->getAABB();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_getAABB)
static bool js_physics_SphereShape_getBoundingSphere(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::Sphere& result = cobj->getBoundingSphere();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_getBoundingSphere)
static bool js_physics_SphereShape_getGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getGroup();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_getGroup)
static bool js_physics_SphereShape_getMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getMask();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_getMask)
static bool js_physics_SphereShape_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_getObjectID)
static bool js_physics_SphereShape_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::Node*, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_initialize)
static bool js_physics_SphereShape_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_onDestroy)
static bool js_physics_SphereShape_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_onDisable)
static bool js_physics_SphereShape_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_onEnable)
static bool js_physics_SphereShape_setAsTrigger(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAsTrigger(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_setAsTrigger)
static bool js_physics_SphereShape_setCenter(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCenter(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_setCenter)
static bool js_physics_SphereShape_setGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setGroup(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_setGroup)
static bool js_physics_SphereShape_setMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMask(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_setMask)
static bool js_physics_SphereShape_setMaterial(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<unsigned short, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<uint8_t, false> arg4 = {};
HolderType<uint8_t, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMaterial(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_setMaterial)
static bool js_physics_SphereShape_setRadius(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<float, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setRadius(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_setRadius)
static bool js_physics_SphereShape_updateEventListener(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::SphereShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::EShapeFilterFlag, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->updateEventListener(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_SphereShape_updateEventListener)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_SphereShape_finalize)
static bool js_physics_SphereShape_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::SphereShape);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_SphereShape_constructor, __jsb_cc_physics_SphereShape_class, js_cc_physics_SphereShape_finalize)
static bool js_cc_physics_SphereShape_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_SphereShape_finalize)
bool js_register_physics_SphereShape(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("SphereShape", obj, nullptr, _SE(js_physics_SphereShape_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("getAABB", _SE(js_physics_SphereShape_getAABB));
cls->defineFunction("getBoundingSphere", _SE(js_physics_SphereShape_getBoundingSphere));
cls->defineFunction("getGroup", _SE(js_physics_SphereShape_getGroup));
cls->defineFunction("getMask", _SE(js_physics_SphereShape_getMask));
cls->defineFunction("getObjectID", _SE(js_physics_SphereShape_getObjectID));
cls->defineFunction("initialize", _SE(js_physics_SphereShape_initialize));
cls->defineFunction("onDestroy", _SE(js_physics_SphereShape_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_SphereShape_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_SphereShape_onEnable));
cls->defineFunction("setAsTrigger", _SE(js_physics_SphereShape_setAsTrigger));
cls->defineFunction("setCenter", _SE(js_physics_SphereShape_setCenter));
cls->defineFunction("setGroup", _SE(js_physics_SphereShape_setGroup));
cls->defineFunction("setMask", _SE(js_physics_SphereShape_setMask));
cls->defineFunction("setMaterial", _SE(js_physics_SphereShape_setMaterial));
cls->defineFunction("setRadius", _SE(js_physics_SphereShape_setRadius));
cls->defineFunction("updateEventListener", _SE(js_physics_SphereShape_updateEventListener));
cls->defineFinalizeFunction(_SE(js_cc_physics_SphereShape_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::SphereShape>(cls);
__jsb_cc_physics_SphereShape_proto = cls->getProto();
__jsb_cc_physics_SphereShape_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_BoxShape_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_BoxShape_class = nullptr; // NOLINT
static bool js_physics_BoxShape_getAABB(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::AABB& result = cobj->getAABB();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_getAABB)
static bool js_physics_BoxShape_getBoundingSphere(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::Sphere& result = cobj->getBoundingSphere();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_getBoundingSphere)
static bool js_physics_BoxShape_getGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getGroup();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_getGroup)
static bool js_physics_BoxShape_getMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getMask();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_getMask)
static bool js_physics_BoxShape_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_getObjectID)
static bool js_physics_BoxShape_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::Node*, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_initialize)
static bool js_physics_BoxShape_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_onDestroy)
static bool js_physics_BoxShape_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_onDisable)
static bool js_physics_BoxShape_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_onEnable)
static bool js_physics_BoxShape_setAsTrigger(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAsTrigger(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_setAsTrigger)
static bool js_physics_BoxShape_setCenter(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCenter(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_setCenter)
static bool js_physics_BoxShape_setGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setGroup(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_setGroup)
static bool js_physics_BoxShape_setMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMask(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_setMask)
static bool js_physics_BoxShape_setMaterial(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<unsigned short, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<uint8_t, false> arg4 = {};
HolderType<uint8_t, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMaterial(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_setMaterial)
static bool js_physics_BoxShape_setSize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setSize(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_setSize)
static bool js_physics_BoxShape_updateEventListener(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::BoxShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::EShapeFilterFlag, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->updateEventListener(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_BoxShape_updateEventListener)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_BoxShape_finalize)
static bool js_physics_BoxShape_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::BoxShape);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_BoxShape_constructor, __jsb_cc_physics_BoxShape_class, js_cc_physics_BoxShape_finalize)
static bool js_cc_physics_BoxShape_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_BoxShape_finalize)
bool js_register_physics_BoxShape(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("BoxShape", obj, nullptr, _SE(js_physics_BoxShape_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("getAABB", _SE(js_physics_BoxShape_getAABB));
cls->defineFunction("getBoundingSphere", _SE(js_physics_BoxShape_getBoundingSphere));
cls->defineFunction("getGroup", _SE(js_physics_BoxShape_getGroup));
cls->defineFunction("getMask", _SE(js_physics_BoxShape_getMask));
cls->defineFunction("getObjectID", _SE(js_physics_BoxShape_getObjectID));
cls->defineFunction("initialize", _SE(js_physics_BoxShape_initialize));
cls->defineFunction("onDestroy", _SE(js_physics_BoxShape_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_BoxShape_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_BoxShape_onEnable));
cls->defineFunction("setAsTrigger", _SE(js_physics_BoxShape_setAsTrigger));
cls->defineFunction("setCenter", _SE(js_physics_BoxShape_setCenter));
cls->defineFunction("setGroup", _SE(js_physics_BoxShape_setGroup));
cls->defineFunction("setMask", _SE(js_physics_BoxShape_setMask));
cls->defineFunction("setMaterial", _SE(js_physics_BoxShape_setMaterial));
cls->defineFunction("setSize", _SE(js_physics_BoxShape_setSize));
cls->defineFunction("updateEventListener", _SE(js_physics_BoxShape_updateEventListener));
cls->defineFinalizeFunction(_SE(js_cc_physics_BoxShape_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::BoxShape>(cls);
__jsb_cc_physics_BoxShape_proto = cls->getProto();
__jsb_cc_physics_BoxShape_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_CapsuleShape_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_CapsuleShape_class = nullptr; // NOLINT
static bool js_physics_CapsuleShape_getAABB(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::AABB& result = cobj->getAABB();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_getAABB)
static bool js_physics_CapsuleShape_getBoundingSphere(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::Sphere& result = cobj->getBoundingSphere();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_getBoundingSphere)
static bool js_physics_CapsuleShape_getGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getGroup();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_getGroup)
static bool js_physics_CapsuleShape_getMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getMask();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_getMask)
static bool js_physics_CapsuleShape_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_getObjectID)
static bool js_physics_CapsuleShape_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::Node*, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_initialize)
static bool js_physics_CapsuleShape_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_onDestroy)
static bool js_physics_CapsuleShape_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_onDisable)
static bool js_physics_CapsuleShape_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_onEnable)
static bool js_physics_CapsuleShape_setAsTrigger(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAsTrigger(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_setAsTrigger)
static bool js_physics_CapsuleShape_setCenter(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCenter(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_setCenter)
static bool js_physics_CapsuleShape_setCylinderHeight(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<float, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCylinderHeight(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_setCylinderHeight)
static bool js_physics_CapsuleShape_setDirection(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::EAxisDirection, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setDirection(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_setDirection)
static bool js_physics_CapsuleShape_setGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setGroup(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_setGroup)
static bool js_physics_CapsuleShape_setMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMask(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_setMask)
static bool js_physics_CapsuleShape_setMaterial(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<unsigned short, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<uint8_t, false> arg4 = {};
HolderType<uint8_t, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMaterial(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_setMaterial)
static bool js_physics_CapsuleShape_setRadius(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<float, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setRadius(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_setRadius)
static bool js_physics_CapsuleShape_updateEventListener(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CapsuleShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::EShapeFilterFlag, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->updateEventListener(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CapsuleShape_updateEventListener)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_CapsuleShape_finalize)
static bool js_physics_CapsuleShape_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::CapsuleShape);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_CapsuleShape_constructor, __jsb_cc_physics_CapsuleShape_class, js_cc_physics_CapsuleShape_finalize)
static bool js_cc_physics_CapsuleShape_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_CapsuleShape_finalize)
bool js_register_physics_CapsuleShape(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("CapsuleShape", obj, nullptr, _SE(js_physics_CapsuleShape_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("getAABB", _SE(js_physics_CapsuleShape_getAABB));
cls->defineFunction("getBoundingSphere", _SE(js_physics_CapsuleShape_getBoundingSphere));
cls->defineFunction("getGroup", _SE(js_physics_CapsuleShape_getGroup));
cls->defineFunction("getMask", _SE(js_physics_CapsuleShape_getMask));
cls->defineFunction("getObjectID", _SE(js_physics_CapsuleShape_getObjectID));
cls->defineFunction("initialize", _SE(js_physics_CapsuleShape_initialize));
cls->defineFunction("onDestroy", _SE(js_physics_CapsuleShape_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_CapsuleShape_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_CapsuleShape_onEnable));
cls->defineFunction("setAsTrigger", _SE(js_physics_CapsuleShape_setAsTrigger));
cls->defineFunction("setCenter", _SE(js_physics_CapsuleShape_setCenter));
cls->defineFunction("setCylinderHeight", _SE(js_physics_CapsuleShape_setCylinderHeight));
cls->defineFunction("setDirection", _SE(js_physics_CapsuleShape_setDirection));
cls->defineFunction("setGroup", _SE(js_physics_CapsuleShape_setGroup));
cls->defineFunction("setMask", _SE(js_physics_CapsuleShape_setMask));
cls->defineFunction("setMaterial", _SE(js_physics_CapsuleShape_setMaterial));
cls->defineFunction("setRadius", _SE(js_physics_CapsuleShape_setRadius));
cls->defineFunction("updateEventListener", _SE(js_physics_CapsuleShape_updateEventListener));
cls->defineFinalizeFunction(_SE(js_cc_physics_CapsuleShape_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::CapsuleShape>(cls);
__jsb_cc_physics_CapsuleShape_proto = cls->getProto();
__jsb_cc_physics_CapsuleShape_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_PlaneShape_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_PlaneShape_class = nullptr; // NOLINT
static bool js_physics_PlaneShape_getAABB(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::AABB& result = cobj->getAABB();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_getAABB)
static bool js_physics_PlaneShape_getBoundingSphere(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::Sphere& result = cobj->getBoundingSphere();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_getBoundingSphere)
static bool js_physics_PlaneShape_getGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getGroup();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_getGroup)
static bool js_physics_PlaneShape_getMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getMask();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_getMask)
static bool js_physics_PlaneShape_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_getObjectID)
static bool js_physics_PlaneShape_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::Node*, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_initialize)
static bool js_physics_PlaneShape_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_onDestroy)
static bool js_physics_PlaneShape_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_onDisable)
static bool js_physics_PlaneShape_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_onEnable)
static bool js_physics_PlaneShape_setAsTrigger(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAsTrigger(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_setAsTrigger)
static bool js_physics_PlaneShape_setCenter(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCenter(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_setCenter)
static bool js_physics_PlaneShape_setConstant(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<float, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setConstant(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_setConstant)
static bool js_physics_PlaneShape_setGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setGroup(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_setGroup)
static bool js_physics_PlaneShape_setMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMask(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_setMask)
static bool js_physics_PlaneShape_setMaterial(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<unsigned short, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<uint8_t, false> arg4 = {};
HolderType<uint8_t, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMaterial(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_setMaterial)
static bool js_physics_PlaneShape_setNormal(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setNormal(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_setNormal)
static bool js_physics_PlaneShape_updateEventListener(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::PlaneShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::EShapeFilterFlag, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->updateEventListener(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_PlaneShape_updateEventListener)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_PlaneShape_finalize)
static bool js_physics_PlaneShape_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::PlaneShape);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_PlaneShape_constructor, __jsb_cc_physics_PlaneShape_class, js_cc_physics_PlaneShape_finalize)
static bool js_cc_physics_PlaneShape_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_PlaneShape_finalize)
bool js_register_physics_PlaneShape(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("PlaneShape", obj, nullptr, _SE(js_physics_PlaneShape_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("getAABB", _SE(js_physics_PlaneShape_getAABB));
cls->defineFunction("getBoundingSphere", _SE(js_physics_PlaneShape_getBoundingSphere));
cls->defineFunction("getGroup", _SE(js_physics_PlaneShape_getGroup));
cls->defineFunction("getMask", _SE(js_physics_PlaneShape_getMask));
cls->defineFunction("getObjectID", _SE(js_physics_PlaneShape_getObjectID));
cls->defineFunction("initialize", _SE(js_physics_PlaneShape_initialize));
cls->defineFunction("onDestroy", _SE(js_physics_PlaneShape_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_PlaneShape_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_PlaneShape_onEnable));
cls->defineFunction("setAsTrigger", _SE(js_physics_PlaneShape_setAsTrigger));
cls->defineFunction("setCenter", _SE(js_physics_PlaneShape_setCenter));
cls->defineFunction("setConstant", _SE(js_physics_PlaneShape_setConstant));
cls->defineFunction("setGroup", _SE(js_physics_PlaneShape_setGroup));
cls->defineFunction("setMask", _SE(js_physics_PlaneShape_setMask));
cls->defineFunction("setMaterial", _SE(js_physics_PlaneShape_setMaterial));
cls->defineFunction("setNormal", _SE(js_physics_PlaneShape_setNormal));
cls->defineFunction("updateEventListener", _SE(js_physics_PlaneShape_updateEventListener));
cls->defineFinalizeFunction(_SE(js_cc_physics_PlaneShape_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::PlaneShape>(cls);
__jsb_cc_physics_PlaneShape_proto = cls->getProto();
__jsb_cc_physics_PlaneShape_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_TrimeshShape_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_TrimeshShape_class = nullptr; // NOLINT
static bool js_physics_TrimeshShape_getAABB(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::AABB& result = cobj->getAABB();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_getAABB)
static bool js_physics_TrimeshShape_getBoundingSphere(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::Sphere& result = cobj->getBoundingSphere();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_getBoundingSphere)
static bool js_physics_TrimeshShape_getGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getGroup();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_getGroup)
static bool js_physics_TrimeshShape_getMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getMask();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_getMask)
static bool js_physics_TrimeshShape_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_getObjectID)
static bool js_physics_TrimeshShape_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::Node*, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_initialize)
static bool js_physics_TrimeshShape_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_onDestroy)
static bool js_physics_TrimeshShape_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_onDisable)
static bool js_physics_TrimeshShape_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_onEnable)
static bool js_physics_TrimeshShape_setAsTrigger(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAsTrigger(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_setAsTrigger)
static bool js_physics_TrimeshShape_setCenter(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCenter(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_setCenter)
static bool js_physics_TrimeshShape_setGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setGroup(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_setGroup)
static bool js_physics_TrimeshShape_setMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMask(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_setMask)
static bool js_physics_TrimeshShape_setMaterial(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<unsigned short, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<uint8_t, false> arg4 = {};
HolderType<uint8_t, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMaterial(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_setMaterial)
static bool js_physics_TrimeshShape_setMesh(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMesh(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_setMesh)
static bool js_physics_TrimeshShape_updateEventListener(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::EShapeFilterFlag, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->updateEventListener(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_updateEventListener)
static bool js_physics_TrimeshShape_useConvex(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TrimeshShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->useConvex(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TrimeshShape_useConvex)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_TrimeshShape_finalize)
static bool js_physics_TrimeshShape_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::TrimeshShape);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_TrimeshShape_constructor, __jsb_cc_physics_TrimeshShape_class, js_cc_physics_TrimeshShape_finalize)
static bool js_cc_physics_TrimeshShape_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_TrimeshShape_finalize)
bool js_register_physics_TrimeshShape(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("TrimeshShape", obj, nullptr, _SE(js_physics_TrimeshShape_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("getAABB", _SE(js_physics_TrimeshShape_getAABB));
cls->defineFunction("getBoundingSphere", _SE(js_physics_TrimeshShape_getBoundingSphere));
cls->defineFunction("getGroup", _SE(js_physics_TrimeshShape_getGroup));
cls->defineFunction("getMask", _SE(js_physics_TrimeshShape_getMask));
cls->defineFunction("getObjectID", _SE(js_physics_TrimeshShape_getObjectID));
cls->defineFunction("initialize", _SE(js_physics_TrimeshShape_initialize));
cls->defineFunction("onDestroy", _SE(js_physics_TrimeshShape_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_TrimeshShape_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_TrimeshShape_onEnable));
cls->defineFunction("setAsTrigger", _SE(js_physics_TrimeshShape_setAsTrigger));
cls->defineFunction("setCenter", _SE(js_physics_TrimeshShape_setCenter));
cls->defineFunction("setGroup", _SE(js_physics_TrimeshShape_setGroup));
cls->defineFunction("setMask", _SE(js_physics_TrimeshShape_setMask));
cls->defineFunction("setMaterial", _SE(js_physics_TrimeshShape_setMaterial));
cls->defineFunction("setMesh", _SE(js_physics_TrimeshShape_setMesh));
cls->defineFunction("updateEventListener", _SE(js_physics_TrimeshShape_updateEventListener));
cls->defineFunction("useConvex", _SE(js_physics_TrimeshShape_useConvex));
cls->defineFinalizeFunction(_SE(js_cc_physics_TrimeshShape_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::TrimeshShape>(cls);
__jsb_cc_physics_TrimeshShape_proto = cls->getProto();
__jsb_cc_physics_TrimeshShape_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_CylinderShape_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_CylinderShape_class = nullptr; // NOLINT
static bool js_physics_CylinderShape_getAABB(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::AABB& result = cobj->getAABB();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_getAABB)
static bool js_physics_CylinderShape_getBoundingSphere(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::Sphere& result = cobj->getBoundingSphere();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_getBoundingSphere)
static bool js_physics_CylinderShape_getGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getGroup();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_getGroup)
static bool js_physics_CylinderShape_getMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getMask();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_getMask)
static bool js_physics_CylinderShape_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_getObjectID)
static bool js_physics_CylinderShape_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::Node*, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_initialize)
static bool js_physics_CylinderShape_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_onDestroy)
static bool js_physics_CylinderShape_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_onDisable)
static bool js_physics_CylinderShape_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_onEnable)
static bool js_physics_CylinderShape_setAsTrigger(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAsTrigger(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_setAsTrigger)
static bool js_physics_CylinderShape_setCenter(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCenter(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_setCenter)
static bool js_physics_CylinderShape_setConvex(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setConvex(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_setConvex)
static bool js_physics_CylinderShape_setCylinder(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<cc::physics::EAxisDirection, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCylinder(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_setCylinder)
static bool js_physics_CylinderShape_setGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setGroup(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_setGroup)
static bool js_physics_CylinderShape_setMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMask(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_setMask)
static bool js_physics_CylinderShape_setMaterial(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<unsigned short, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<uint8_t, false> arg4 = {};
HolderType<uint8_t, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMaterial(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_setMaterial)
static bool js_physics_CylinderShape_updateEventListener(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::CylinderShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::EShapeFilterFlag, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->updateEventListener(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_CylinderShape_updateEventListener)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_CylinderShape_finalize)
static bool js_physics_CylinderShape_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::CylinderShape);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_CylinderShape_constructor, __jsb_cc_physics_CylinderShape_class, js_cc_physics_CylinderShape_finalize)
static bool js_cc_physics_CylinderShape_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_CylinderShape_finalize)
bool js_register_physics_CylinderShape(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("CylinderShape", obj, nullptr, _SE(js_physics_CylinderShape_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("getAABB", _SE(js_physics_CylinderShape_getAABB));
cls->defineFunction("getBoundingSphere", _SE(js_physics_CylinderShape_getBoundingSphere));
cls->defineFunction("getGroup", _SE(js_physics_CylinderShape_getGroup));
cls->defineFunction("getMask", _SE(js_physics_CylinderShape_getMask));
cls->defineFunction("getObjectID", _SE(js_physics_CylinderShape_getObjectID));
cls->defineFunction("initialize", _SE(js_physics_CylinderShape_initialize));
cls->defineFunction("onDestroy", _SE(js_physics_CylinderShape_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_CylinderShape_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_CylinderShape_onEnable));
cls->defineFunction("setAsTrigger", _SE(js_physics_CylinderShape_setAsTrigger));
cls->defineFunction("setCenter", _SE(js_physics_CylinderShape_setCenter));
cls->defineFunction("setConvex", _SE(js_physics_CylinderShape_setConvex));
cls->defineFunction("setCylinder", _SE(js_physics_CylinderShape_setCylinder));
cls->defineFunction("setGroup", _SE(js_physics_CylinderShape_setGroup));
cls->defineFunction("setMask", _SE(js_physics_CylinderShape_setMask));
cls->defineFunction("setMaterial", _SE(js_physics_CylinderShape_setMaterial));
cls->defineFunction("updateEventListener", _SE(js_physics_CylinderShape_updateEventListener));
cls->defineFinalizeFunction(_SE(js_cc_physics_CylinderShape_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::CylinderShape>(cls);
__jsb_cc_physics_CylinderShape_proto = cls->getProto();
__jsb_cc_physics_CylinderShape_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_ConeShape_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_ConeShape_class = nullptr; // NOLINT
static bool js_physics_ConeShape_getAABB(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::AABB& result = cobj->getAABB();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_getAABB)
static bool js_physics_ConeShape_getBoundingSphere(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::Sphere& result = cobj->getBoundingSphere();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_getBoundingSphere)
static bool js_physics_ConeShape_getGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getGroup();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_getGroup)
static bool js_physics_ConeShape_getMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getMask();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_getMask)
static bool js_physics_ConeShape_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_getObjectID)
static bool js_physics_ConeShape_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::Node*, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_initialize)
static bool js_physics_ConeShape_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_onDestroy)
static bool js_physics_ConeShape_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_onDisable)
static bool js_physics_ConeShape_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_onEnable)
static bool js_physics_ConeShape_setAsTrigger(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAsTrigger(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_setAsTrigger)
static bool js_physics_ConeShape_setCenter(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCenter(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_setCenter)
static bool js_physics_ConeShape_setCone(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<cc::physics::EAxisDirection, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCone(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_setCone)
static bool js_physics_ConeShape_setConvex(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setConvex(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_setConvex)
static bool js_physics_ConeShape_setGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setGroup(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_setGroup)
static bool js_physics_ConeShape_setMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMask(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_setMask)
static bool js_physics_ConeShape_setMaterial(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<unsigned short, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<uint8_t, false> arg4 = {};
HolderType<uint8_t, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMaterial(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_setMaterial)
static bool js_physics_ConeShape_updateEventListener(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::ConeShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::EShapeFilterFlag, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->updateEventListener(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_ConeShape_updateEventListener)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_ConeShape_finalize)
static bool js_physics_ConeShape_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::ConeShape);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_ConeShape_constructor, __jsb_cc_physics_ConeShape_class, js_cc_physics_ConeShape_finalize)
static bool js_cc_physics_ConeShape_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_ConeShape_finalize)
bool js_register_physics_ConeShape(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("ConeShape", obj, nullptr, _SE(js_physics_ConeShape_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("getAABB", _SE(js_physics_ConeShape_getAABB));
cls->defineFunction("getBoundingSphere", _SE(js_physics_ConeShape_getBoundingSphere));
cls->defineFunction("getGroup", _SE(js_physics_ConeShape_getGroup));
cls->defineFunction("getMask", _SE(js_physics_ConeShape_getMask));
cls->defineFunction("getObjectID", _SE(js_physics_ConeShape_getObjectID));
cls->defineFunction("initialize", _SE(js_physics_ConeShape_initialize));
cls->defineFunction("onDestroy", _SE(js_physics_ConeShape_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_ConeShape_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_ConeShape_onEnable));
cls->defineFunction("setAsTrigger", _SE(js_physics_ConeShape_setAsTrigger));
cls->defineFunction("setCenter", _SE(js_physics_ConeShape_setCenter));
cls->defineFunction("setCone", _SE(js_physics_ConeShape_setCone));
cls->defineFunction("setConvex", _SE(js_physics_ConeShape_setConvex));
cls->defineFunction("setGroup", _SE(js_physics_ConeShape_setGroup));
cls->defineFunction("setMask", _SE(js_physics_ConeShape_setMask));
cls->defineFunction("setMaterial", _SE(js_physics_ConeShape_setMaterial));
cls->defineFunction("updateEventListener", _SE(js_physics_ConeShape_updateEventListener));
cls->defineFinalizeFunction(_SE(js_cc_physics_ConeShape_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::ConeShape>(cls);
__jsb_cc_physics_ConeShape_proto = cls->getProto();
__jsb_cc_physics_ConeShape_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_TerrainShape_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_TerrainShape_class = nullptr; // NOLINT
static bool js_physics_TerrainShape_getAABB(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::AABB& result = cobj->getAABB();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_getAABB)
static bool js_physics_TerrainShape_getBoundingSphere(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::geometry::Sphere& result = cobj->getBoundingSphere();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_getBoundingSphere)
static bool js_physics_TerrainShape_getGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getGroup();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_getGroup)
static bool js_physics_TerrainShape_getMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getMask();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_getMask)
static bool js_physics_TerrainShape_getObjectID(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getObjectID();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_getObjectID)
static bool js_physics_TerrainShape_initialize(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::Node*, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->initialize(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_initialize)
static bool js_physics_TerrainShape_onDestroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDestroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_onDestroy)
static bool js_physics_TerrainShape_onDisable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onDisable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_onDisable)
static bool js_physics_TerrainShape_onEnable(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onEnable();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_onEnable)
static bool js_physics_TerrainShape_setAsTrigger(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAsTrigger(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_setAsTrigger)
static bool js_physics_TerrainShape_setCenter(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCenter(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_setCenter)
static bool js_physics_TerrainShape_setGroup(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setGroup(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_setGroup)
static bool js_physics_TerrainShape_setMask(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<unsigned int, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMask(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_setMask)
static bool js_physics_TerrainShape_setMaterial(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<unsigned short, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<uint8_t, false> arg4 = {};
HolderType<uint8_t, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setMaterial(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_setMaterial)
static bool js_physics_TerrainShape_setTerrain(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 4) {
HolderType<unsigned int, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setTerrain(arg0.value(), arg1.value(), arg2.value(), arg3.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_setTerrain)
static bool js_physics_TerrainShape_updateEventListener(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::TerrainShape>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::EShapeFilterFlag, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->updateEventListener(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_TerrainShape_updateEventListener)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_TerrainShape_finalize)
static bool js_physics_TerrainShape_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::TerrainShape);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_TerrainShape_constructor, __jsb_cc_physics_TerrainShape_class, js_cc_physics_TerrainShape_finalize)
static bool js_cc_physics_TerrainShape_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_TerrainShape_finalize)
bool js_register_physics_TerrainShape(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("TerrainShape", obj, nullptr, _SE(js_physics_TerrainShape_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("getAABB", _SE(js_physics_TerrainShape_getAABB));
cls->defineFunction("getBoundingSphere", _SE(js_physics_TerrainShape_getBoundingSphere));
cls->defineFunction("getGroup", _SE(js_physics_TerrainShape_getGroup));
cls->defineFunction("getMask", _SE(js_physics_TerrainShape_getMask));
cls->defineFunction("getObjectID", _SE(js_physics_TerrainShape_getObjectID));
cls->defineFunction("initialize", _SE(js_physics_TerrainShape_initialize));
cls->defineFunction("onDestroy", _SE(js_physics_TerrainShape_onDestroy));
cls->defineFunction("onDisable", _SE(js_physics_TerrainShape_onDisable));
cls->defineFunction("onEnable", _SE(js_physics_TerrainShape_onEnable));
cls->defineFunction("setAsTrigger", _SE(js_physics_TerrainShape_setAsTrigger));
cls->defineFunction("setCenter", _SE(js_physics_TerrainShape_setCenter));
cls->defineFunction("setGroup", _SE(js_physics_TerrainShape_setGroup));
cls->defineFunction("setMask", _SE(js_physics_TerrainShape_setMask));
cls->defineFunction("setMaterial", _SE(js_physics_TerrainShape_setMaterial));
cls->defineFunction("setTerrain", _SE(js_physics_TerrainShape_setTerrain));
cls->defineFunction("updateEventListener", _SE(js_physics_TerrainShape_updateEventListener));
cls->defineFinalizeFunction(_SE(js_cc_physics_TerrainShape_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::TerrainShape>(cls);
__jsb_cc_physics_TerrainShape_proto = cls->getProto();
__jsb_cc_physics_TerrainShape_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_physics_World_proto = nullptr; // NOLINT
se::Class* __jsb_cc_physics_World_class = nullptr; // NOLINT
static bool js_physics_World_createConvex(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::ConvexDesc, true> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
unsigned int result = cobj->createConvex(arg0.value());
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_World_createConvex)
static bool js_physics_World_createHeightField(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::HeightFieldDesc, true> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
unsigned int result = cobj->createHeightField(arg0.value());
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_World_createHeightField)
static bool js_physics_World_createMaterial(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 6) {
HolderType<unsigned short, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
HolderType<float, false> arg3 = {};
HolderType<uint8_t, false> arg4 = {};
HolderType<uint8_t, false> arg5 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
ok &= sevalue_to_native(args[3], &arg3, s.thisObject());
ok &= sevalue_to_native(args[4], &arg4, s.thisObject());
ok &= sevalue_to_native(args[5], &arg5, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
bool result = cobj->createMaterial(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value());
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
return false;
}
SE_BIND_FUNC(js_physics_World_createMaterial)
static bool js_physics_World_createTrimesh(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::TrimeshDesc, true> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
unsigned int result = cobj->createTrimesh(arg0.value());
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_World_createTrimesh)
static bool js_physics_World_destroy(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->destroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_World_destroy)
static bool js_physics_World_emitEvents(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->emitEvents();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_World_emitEvents)
static bool js_physics_World_getContactEventPairs(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
std::vector<std::shared_ptr<cc::physics::ContactEventPair>>& result = cobj->getContactEventPairs();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_World_getContactEventPairs)
static bool js_physics_World_getTriggerEventPairs(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
std::vector<std::shared_ptr<cc::physics::TriggerEventPair>>& result = cobj->getTriggerEventPairs();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_World_getTriggerEventPairs)
static bool js_physics_World_raycast(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::RaycastOptions, true> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
bool result = cobj->raycast(arg0.value());
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_World_raycast)
static bool js_physics_World_raycastClosest(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<cc::physics::RaycastOptions, true> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
bool result = cobj->raycastClosest(arg0.value());
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_World_raycastClosest)
static bool js_physics_World_raycastClosestResult(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::physics::RaycastResult& result = cobj->raycastClosestResult();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_World_raycastClosestResult)
static bool js_physics_World_raycastResult(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
std::vector<cc::physics::RaycastResult>& result = cobj->raycastResult();
ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/);
SE_PRECONDITION2(ok, false, "Error processing arguments");
SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_World_raycastResult)
static bool js_physics_World_setAllowSleep(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<bool, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setAllowSleep(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_World_setAllowSleep)
static bool js_physics_World_setCollisionMatrix(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 2) {
HolderType<unsigned int, false> arg0 = {};
HolderType<unsigned int, false> arg1 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setCollisionMatrix(arg0.value(), arg1.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
return false;
}
SE_BIND_FUNC(js_physics_World_setCollisionMatrix)
static bool js_physics_World_setGravity(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 3) {
HolderType<float, false> arg0 = {};
HolderType<float, false> arg1 = {};
HolderType<float, false> arg2 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
ok &= sevalue_to_native(args[1], &arg1, s.thisObject());
ok &= sevalue_to_native(args[2], &arg2, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->setGravity(arg0.value(), arg1.value(), arg2.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
return false;
}
SE_BIND_FUNC(js_physics_World_setGravity)
static bool js_physics_World_step(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
HolderType<float, false> arg0 = {};
ok &= sevalue_to_native(args[0], &arg0, s.thisObject());
SE_PRECONDITION2(ok, false, "Error processing arguments");
cobj->step(arg0.value());
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_physics_World_step)
static bool js_physics_World_syncSceneToPhysics(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->syncSceneToPhysics();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_World_syncSceneToPhysics)
static bool js_physics_World_syncSceneWithCheck(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::physics::World>(s);
// SE_PRECONDITION2(cobj, false, "Invalid Native Object");
if (nullptr == cobj) return true;
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->syncSceneWithCheck();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_physics_World_syncSceneWithCheck)
SE_DECLARE_FINALIZE_FUNC(js_cc_physics_World_finalize)
static bool js_physics_World_constructor(se::State& s) // NOLINT(readability-identifier-naming) constructor.c
{
auto *ptr = JSB_MAKE_PRIVATE_OBJECT(cc::physics::World);
s.thisObject()->setPrivateObject(ptr);
return true;
}
SE_BIND_CTOR(js_physics_World_constructor, __jsb_cc_physics_World_class, js_cc_physics_World_finalize)
static bool js_cc_physics_World_finalize(se::State& s) // NOLINT(readability-identifier-naming)
{
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_physics_World_finalize)
bool js_register_physics_World(se::Object* obj) // NOLINT(readability-identifier-naming)
{
auto* cls = se::Class::create("World", obj, nullptr, _SE(js_physics_World_constructor));
#if CC_DEBUG
cls->defineStaticProperty("isJSBClass", _SE(js_physics_getter_return_true), nullptr);
#endif
cls->defineFunction("createConvex", _SE(js_physics_World_createConvex));
cls->defineFunction("createHeightField", _SE(js_physics_World_createHeightField));
cls->defineFunction("createMaterial", _SE(js_physics_World_createMaterial));
cls->defineFunction("createTrimesh", _SE(js_physics_World_createTrimesh));
cls->defineFunction("destroy", _SE(js_physics_World_destroy));
cls->defineFunction("emitEvents", _SE(js_physics_World_emitEvents));
cls->defineFunction("getContactEventPairs", _SE(js_physics_World_getContactEventPairs));
cls->defineFunction("getTriggerEventPairs", _SE(js_physics_World_getTriggerEventPairs));
cls->defineFunction("raycast", _SE(js_physics_World_raycast));
cls->defineFunction("raycastClosest", _SE(js_physics_World_raycastClosest));
cls->defineFunction("raycastClosestResult", _SE(js_physics_World_raycastClosestResult));
cls->defineFunction("raycastResult", _SE(js_physics_World_raycastResult));
cls->defineFunction("setAllowSleep", _SE(js_physics_World_setAllowSleep));
cls->defineFunction("setCollisionMatrix", _SE(js_physics_World_setCollisionMatrix));
cls->defineFunction("setGravity", _SE(js_physics_World_setGravity));
cls->defineFunction("step", _SE(js_physics_World_step));
cls->defineFunction("syncSceneToPhysics", _SE(js_physics_World_syncSceneToPhysics));
cls->defineFunction("syncSceneWithCheck", _SE(js_physics_World_syncSceneWithCheck));
cls->defineFinalizeFunction(_SE(js_cc_physics_World_finalize));
cls->install();
JSBClassType::registerClass<cc::physics::World>(cls);
__jsb_cc_physics_World_proto = cls->getProto();
__jsb_cc_physics_World_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
bool register_all_physics(se::Object* obj) // NOLINT
{
// Get the ns
se::Value nsVal;
if (!obj->getProperty("jsb.physics", &nsVal, true))
{
se::HandleObject jsobj(se::Object::createPlainObject());
nsVal.setObject(jsobj);
obj->setProperty("jsb.physics", nsVal);
}
se::Object* ns = nsVal.toObject();
js_register_physics_BoxShape(ns);
js_register_physics_CapsuleShape(ns);
js_register_physics_ConeShape(ns);
js_register_physics_CylinderShape(ns);
js_register_physics_DistanceJoint(ns);
js_register_physics_PlaneShape(ns);
js_register_physics_RevoluteJoint(ns);
js_register_physics_RigidBody(ns);
js_register_physics_SphereShape(ns);
js_register_physics_TerrainShape(ns);
js_register_physics_TrimeshShape(ns);
js_register_physics_World(ns);
return true;
}
// clang-format on