// clang-format off

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.1.0
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

/****************************************************************************
 Copyright (c) 2022-2023 Xiamen Yaji Software Co., Ltd.

 http://www.cocos.com

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights to
 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 of the Software, and to permit persons to whom the Software is furnished to do so,
 subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
****************************************************************************/

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-variable"
#elif defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-variable"
#elif defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4101)
#endif


#define SWIG_STD_MOVE(OBJ) std::move(OBJ)


#include <stdio.h>


#include "bindings/jswrapper/SeApi.h"
#include "bindings/manual/jsb_conversions.h"
#include "bindings/manual/jsb_global.h"


#include "bindings/auto/jsb_geometry_auto.h"
#include "bindings/auto/jsb_cocos_auto.h"
#include "bindings/auto/jsb_scene_auto.h"
#include "bindings/auto/jsb_gi_auto.h"

using namespace cc;
using namespace cc::gi;


#define cc_gi_LightProbesData_probes_get(self_) self_->getProbes()
#define cc_gi_LightProbesData_probes_set(self_, val_) self_->setProbes(val_)
  

#define cc_gi_LightProbesData_tetrahedrons_get(self_) self_->getTetrahedrons()
#define cc_gi_LightProbesData_tetrahedrons_set(self_, val_) self_->setTetrahedrons(val_)
  

#define cc_gi_LightProbes_giScale_get(self_) self_->getGIScale()
#define cc_gi_LightProbes_giScale_set(self_, val_) self_->setGIScale(val_)
  

#define cc_gi_LightProbes_giSamples_get(self_) self_->getGISamples()
#define cc_gi_LightProbes_giSamples_set(self_, val_) self_->setGISamples(val_)
  

#define cc_gi_LightProbes_bounces_get(self_) self_->getBounces()
#define cc_gi_LightProbes_bounces_set(self_, val_) self_->setBounces(val_)
  

#define cc_gi_LightProbes_reduceRinging_get(self_) self_->getReduceRinging()
#define cc_gi_LightProbes_reduceRinging_set(self_, val_) self_->setReduceRinging(val_)
  

#define cc_gi_LightProbes_showProbe_get(self_) self_->isShowProbe()
#define cc_gi_LightProbes_showProbe_set(self_, val_) self_->setShowProbe(val_)
  

#define cc_gi_LightProbes_showWireframe_get(self_) self_->isShowWireframe()
#define cc_gi_LightProbes_showWireframe_set(self_, val_) self_->setShowWireframe(val_)
  

#define cc_gi_LightProbes_lightProbeSphereVolume_get(self_) self_->getLightProbeSphereVolume()
#define cc_gi_LightProbes_lightProbeSphereVolume_set(self_, val_) self_->setLightProbeSphereVolume(val_)
  

#define cc_gi_LightProbes_showConvex_get(self_) self_->isShowConvex()
#define cc_gi_LightProbes_showConvex_set(self_, val_) self_->setShowConvex(val_)
  

#define cc_gi_LightProbes_data_get(self_) self_->getData()
#define cc_gi_LightProbes_data_set(self_, val_) self_->setData(val_)
  

#define cc_gi_LightProbeInfo_giScale_get(self_) self_->getGIScale()
#define cc_gi_LightProbeInfo_giScale_set(self_, val_) self_->setGIScale(val_)
  

#define cc_gi_LightProbeInfo_giSamples_get(self_) self_->getGISamples()
#define cc_gi_LightProbeInfo_giSamples_set(self_, val_) self_->setGISamples(val_)
  

#define cc_gi_LightProbeInfo_bounces_get(self_) self_->getBounces()
#define cc_gi_LightProbeInfo_bounces_set(self_, val_) self_->setBounces(val_)
  

#define cc_gi_LightProbeInfo_lightProbeSphereVolume_get(self_) self_->getLightProbeSphereVolume()
#define cc_gi_LightProbeInfo_lightProbeSphereVolume_set(self_, val_) self_->setLightProbeSphereVolume(val_)
  

#define cc_gi_LightProbeInfo_reduceRinging_get(self_) self_->getReduceRinging()
#define cc_gi_LightProbeInfo_reduceRinging_set(self_, val_) self_->setReduceRinging(val_)
  

#define cc_gi_LightProbeInfo_showProbe_get(self_) self_->isShowProbe()
#define cc_gi_LightProbeInfo_showProbe_set(self_, val_) self_->setShowProbe(val_)
  

#define cc_gi_LightProbeInfo_showWireframe_get(self_) self_->isShowWireframe()
#define cc_gi_LightProbeInfo_showWireframe_set(self_, val_) self_->setShowWireframe(val_)
  

#define cc_gi_LightProbeInfo_showConvex_get(self_) self_->isShowConvex()
#define cc_gi_LightProbeInfo_showConvex_set(self_, val_) self_->setShowConvex(val_)
  

#define cc_gi_LightProbeInfo_data_get(self_) self_->getData()
#define cc_gi_LightProbeInfo_data_set(self_, val_) self_->setData(val_)
  


se::Class* __jsb_cc_gi_Vertex_class = nullptr;
se::Object* __jsb_cc_gi_Vertex_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_Vertex) 

static bool js_cc_gi_Vertex_coefficients_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Vertex>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->coefficients, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Vertex_coefficients_set) 

static bool js_cc_gi_Vertex_coefficients_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Vertex>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->coefficients, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->coefficients, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Vertex_coefficients_get) 

static bool js_cc_gi_Vertex_position_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Vertex>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->position, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Vertex_position_set) 

static bool js_cc_gi_Vertex_position_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Vertex>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->position, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->position, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Vertex_position_get) 

static bool js_cc_gi_Vertex_normal_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Vertex>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->normal, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Vertex_normal_set) 

static bool js_cc_gi_Vertex_normal_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Vertex>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->normal, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->normal, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Vertex_normal_get) 

static bool js_new_cc_gi_Vertex__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::gi::Vertex *result;
    result = (cc::gi::Vertex *)new cc::gi::Vertex();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_gi_Vertex__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    Vec3 *arg1 = 0 ;
    Vec3 temp1 ;
    cc::gi::Vertex *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::gi::Vertex *)new cc::gi::Vertex((Vec3 const &)*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_gi_Vertex(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 0) {
        ret = js_new_cc_gi_Vertex__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_gi_Vertex__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of Vertex");
    return false;
}
SE_BIND_CTOR(js_new_cc_gi_Vertex, __jsb_cc_gi_Vertex_class, js_delete_cc_gi_Vertex)

static bool js_delete_cc_gi_Vertex(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_Vertex) 

template<>
bool sevalue_to_native(const se::Value &from, cc::gi::Vertex * to, se::Object *ctx)
{
    assert(from.isObject());
    se::Object *json = from.toObject();
    auto* data = reinterpret_cast<cc::gi::Vertex*>(json->getPrivateData());
    if (data) {
        *to = *data;
        return true;
    }
    se::Value field;
    bool ok = true;
    
    json->getProperty("coefficients", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->coefficients), ctx);
    }
    
    
    json->getProperty("position", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->position), ctx);
    }
    
    
    json->getProperty("normal", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->normal), ctx);
    }
    
    
    return ok;
}


bool js_register_cc_gi_Vertex(se::Object* obj) {
    auto* cls = se::Class::create("Vertex", obj, nullptr, _SE(js_new_cc_gi_Vertex)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("coefficients", _SE(js_cc_gi_Vertex_coefficients_get), _SE(js_cc_gi_Vertex_coefficients_set)); 
    cls->defineProperty("position", _SE(js_cc_gi_Vertex_position_get), _SE(js_cc_gi_Vertex_position_set)); 
    cls->defineProperty("normal", _SE(js_cc_gi_Vertex_normal_get), _SE(js_cc_gi_Vertex_normal_set)); 
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_gi_Vertex));
    
    
    cls->install();
    JSBClassType::registerClass<cc::gi::Vertex>(cls);
    
    __jsb_cc_gi_Vertex_proto = cls->getProto();
    __jsb_cc_gi_Vertex_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_gi_CircumSphere_class = nullptr;
se::Object* __jsb_cc_gi_CircumSphere_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_CircumSphere) 

static bool js_cc_gi_CircumSphere_radiusSquared_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::CircumSphere>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->radiusSquared, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_CircumSphere_radiusSquared_set) 

static bool js_cc_gi_CircumSphere_radiusSquared_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::CircumSphere>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->radiusSquared, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_CircumSphere_radiusSquared_get) 

static bool js_cc_gi_CircumSphere_center_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::CircumSphere>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->center, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_CircumSphere_center_set) 

static bool js_cc_gi_CircumSphere_center_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::CircumSphere>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->center, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->center, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_CircumSphere_center_get) 

static bool js_new_cc_gi_CircumSphere(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    cc::gi::CircumSphere *result;
    result = (cc::gi::CircumSphere *)new cc::gi::CircumSphere();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_gi_CircumSphere, __jsb_cc_gi_CircumSphere_class, js_delete_cc_gi_CircumSphere)

static bool js_cc_gi_CircumSphere_init(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ;
    Vec3 *arg2 = 0 ;
    Vec3 *arg3 = 0 ;
    Vec3 *arg4 = 0 ;
    Vec3 *arg5 = 0 ;
    Vec3 temp2 ;
    Vec3 temp3 ;
    Vec3 temp4 ;
    Vec3 temp5 ;
    
    if(argc != 4) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::CircumSphere>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    
    ok &= sevalue_to_native(args[2], &temp4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg4 = &temp4;
    
    
    ok &= sevalue_to_native(args[3], &temp5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg5 = &temp5;
    
    (arg1)->init((Vec3 const &)*arg2,(Vec3 const &)*arg3,(Vec3 const &)*arg4,(Vec3 const &)*arg5);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_CircumSphere_init) 

static bool js_delete_cc_gi_CircumSphere(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_CircumSphere) 

template<>
bool sevalue_to_native(const se::Value &from, cc::gi::CircumSphere * to, se::Object *ctx)
{
    assert(from.isObject());
    se::Object *json = from.toObject();
    auto* data = reinterpret_cast<cc::gi::CircumSphere*>(json->getPrivateData());
    if (data) {
        *to = *data;
        return true;
    }
    se::Value field;
    bool ok = true;
    
    json->getProperty("radiusSquared", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->radiusSquared), ctx);
    }
    
    
    json->getProperty("center", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->center), ctx);
    }
    
    
    return ok;
}


bool js_register_cc_gi_CircumSphere(se::Object* obj) {
    auto* cls = se::Class::create("CircumSphere", obj, nullptr, _SE(js_new_cc_gi_CircumSphere)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("radiusSquared", _SE(js_cc_gi_CircumSphere_radiusSquared_get), _SE(js_cc_gi_CircumSphere_radiusSquared_set)); 
    cls->defineProperty("center", _SE(js_cc_gi_CircumSphere_center_get), _SE(js_cc_gi_CircumSphere_center_set)); 
    
    cls->defineFunction("init", _SE(js_cc_gi_CircumSphere_init)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_gi_CircumSphere));
    
    
    cls->install();
    JSBClassType::registerClass<cc::gi::CircumSphere>(cls);
    
    __jsb_cc_gi_CircumSphere_proto = cls->getProto();
    __jsb_cc_gi_CircumSphere_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_gi_Tetrahedron_class = nullptr;
se::Object* __jsb_cc_gi_Tetrahedron_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_Tetrahedron) 

static bool js_cc_gi_Tetrahedron_invalid_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->invalid);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_invalid_set) 

static bool js_cc_gi_Tetrahedron_invalid_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->invalid, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_invalid_get) 

static bool js_cc_gi_Tetrahedron_vertex0_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->vertex0, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex0_set) 

static bool js_cc_gi_Tetrahedron_vertex0_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->vertex0, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex0_get) 

static bool js_cc_gi_Tetrahedron_vertex1_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->vertex1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex1_set) 

static bool js_cc_gi_Tetrahedron_vertex1_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->vertex1, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex1_get) 

static bool js_cc_gi_Tetrahedron_vertex2_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->vertex2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex2_set) 

static bool js_cc_gi_Tetrahedron_vertex2_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->vertex2, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex2_get) 

static bool js_cc_gi_Tetrahedron_vertex3_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->vertex3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex3_set) 

static bool js_cc_gi_Tetrahedron_vertex3_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->vertex3, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex3_get) 

static bool js_cc_gi_Tetrahedron_neighbours_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->neighbours, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_neighbours_set) 

static bool js_cc_gi_Tetrahedron_neighbours_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->neighbours, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->neighbours, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_neighbours_get) 

static bool js_cc_gi_Tetrahedron_matrix_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->matrix, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_matrix_set) 

static bool js_cc_gi_Tetrahedron_matrix_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->matrix, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->matrix, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_matrix_get) 

static bool js_cc_gi_Tetrahedron_offset_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_offset_set) 

static bool js_cc_gi_Tetrahedron_offset_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->offset, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_offset_get) 

static bool js_cc_gi_Tetrahedron_sphere_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->sphere, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_sphere_set) 

static bool js_cc_gi_Tetrahedron_sphere_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->sphere, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->sphere, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_sphere_get) 

static bool js_new_cc_gi_Tetrahedron__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::gi::Delaunay *arg1 = (cc::gi::Delaunay *) NULL ;
    int32_t arg2 ;
    int32_t arg3 ;
    int32_t arg4 ;
    int32_t arg5 ;
    cc::gi::Tetrahedron *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[4], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::gi::Tetrahedron *)new cc::gi::Tetrahedron((cc::gi::Delaunay const *)arg1,arg2,arg3,arg4,arg5);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_gi_Tetrahedron__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::gi::Delaunay *arg1 = (cc::gi::Delaunay *) NULL ;
    int32_t arg2 ;
    int32_t arg3 ;
    int32_t arg4 ;
    cc::gi::Tetrahedron *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::gi::Tetrahedron *)new cc::gi::Tetrahedron((cc::gi::Delaunay const *)arg1,arg2,arg3,arg4);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_gi_Tetrahedron__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::gi::Tetrahedron *result;
    result = (cc::gi::Tetrahedron *)new cc::gi::Tetrahedron();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_gi_Tetrahedron(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 5) {
        ret = js_new_cc_gi_Tetrahedron__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 4) {
        ret = js_new_cc_gi_Tetrahedron__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 0) {
        ret = js_new_cc_gi_Tetrahedron__SWIG_2(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of Tetrahedron");
    return false;
}
SE_BIND_CTOR(js_new_cc_gi_Tetrahedron, __jsb_cc_gi_Tetrahedron_class, js_delete_cc_gi_Tetrahedron)

static bool js_cc_gi_Tetrahedron_isInCircumSphere(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    Vec3 *arg2 = 0 ;
    Vec3 temp2 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (bool)((cc::gi::Tetrahedron const *)arg1)->isInCircumSphere((Vec3 const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_Tetrahedron_isInCircumSphere) 

static bool js_cc_gi_Tetrahedron_contain(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    int32_t arg2 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (bool)((cc::gi::Tetrahedron const *)arg1)->contain(arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_Tetrahedron_contain) 

static bool js_cc_gi_Tetrahedron_isInnerTetrahedron(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    bool result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::gi::Tetrahedron const *)arg1)->isInnerTetrahedron();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_Tetrahedron_isInnerTetrahedron) 

static bool js_cc_gi_Tetrahedron_isOuterCell(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ;
    bool result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::Tetrahedron>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::gi::Tetrahedron const *)arg1)->isOuterCell();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_Tetrahedron_isOuterCell) 

static bool js_delete_cc_gi_Tetrahedron(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_Tetrahedron) 

template<>
bool sevalue_to_native(const se::Value &from, cc::gi::Tetrahedron * to, se::Object *ctx)
{
    assert(from.isObject());
    se::Object *json = from.toObject();
    auto* data = reinterpret_cast<cc::gi::Tetrahedron*>(json->getPrivateData());
    if (data) {
        *to = *data;
        return true;
    }
    se::Value field;
    bool ok = true;
    
    json->getProperty("invalid", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->invalid), ctx);
    }
    
    
    json->getProperty("vertex0", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->vertex0), ctx);
    }
    
    
    json->getProperty("vertex1", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->vertex1), ctx);
    }
    
    
    json->getProperty("vertex2", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->vertex2), ctx);
    }
    
    
    json->getProperty("vertex3", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->vertex3), ctx);
    }
    
    
    json->getProperty("neighbours", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->neighbours), ctx);
    }
    
    
    json->getProperty("matrix", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->matrix), ctx);
    }
    
    
    json->getProperty("offset", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->offset), ctx);
    }
    
    
    json->getProperty("sphere", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->sphere), ctx);
    }
    
    
    return ok;
}


bool js_register_cc_gi_Tetrahedron(se::Object* obj) {
    auto* cls = se::Class::create("Tetrahedron", obj, nullptr, _SE(js_new_cc_gi_Tetrahedron)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("invalid", _SE(js_cc_gi_Tetrahedron_invalid_get), _SE(js_cc_gi_Tetrahedron_invalid_set)); 
    cls->defineProperty("vertex0", _SE(js_cc_gi_Tetrahedron_vertex0_get), _SE(js_cc_gi_Tetrahedron_vertex0_set)); 
    cls->defineProperty("vertex1", _SE(js_cc_gi_Tetrahedron_vertex1_get), _SE(js_cc_gi_Tetrahedron_vertex1_set)); 
    cls->defineProperty("vertex2", _SE(js_cc_gi_Tetrahedron_vertex2_get), _SE(js_cc_gi_Tetrahedron_vertex2_set)); 
    cls->defineProperty("vertex3", _SE(js_cc_gi_Tetrahedron_vertex3_get), _SE(js_cc_gi_Tetrahedron_vertex3_set)); 
    cls->defineProperty("neighbours", _SE(js_cc_gi_Tetrahedron_neighbours_get), _SE(js_cc_gi_Tetrahedron_neighbours_set)); 
    cls->defineProperty("matrix", _SE(js_cc_gi_Tetrahedron_matrix_get), _SE(js_cc_gi_Tetrahedron_matrix_set)); 
    cls->defineProperty("offset", _SE(js_cc_gi_Tetrahedron_offset_get), _SE(js_cc_gi_Tetrahedron_offset_set)); 
    cls->defineProperty("sphere", _SE(js_cc_gi_Tetrahedron_sphere_get), _SE(js_cc_gi_Tetrahedron_sphere_set)); 
    
    cls->defineFunction("isInCircumSphere", _SE(js_cc_gi_Tetrahedron_isInCircumSphere)); 
    cls->defineFunction("contain", _SE(js_cc_gi_Tetrahedron_contain)); 
    cls->defineFunction("isInnerTetrahedron", _SE(js_cc_gi_Tetrahedron_isInnerTetrahedron)); 
    cls->defineFunction("isOuterCell", _SE(js_cc_gi_Tetrahedron_isOuterCell)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_gi_Tetrahedron));
    
    
    cls->install();
    JSBClassType::registerClass<cc::gi::Tetrahedron>(cls);
    
    __jsb_cc_gi_Tetrahedron_proto = cls->getProto();
    __jsb_cc_gi_Tetrahedron_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_gi_Delaunay_class = nullptr;
se::Object* __jsb_cc_gi_Delaunay_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_Delaunay) 

static bool js_new_cc_gi_Delaunay(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    if (argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    
    ccstd::vector< cc::gi::Vertex > *arg1 = 0 ;
    ccstd::vector< cc::gi::Vertex > temp1 ;
    cc::gi::Delaunay *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::gi::Delaunay *)new cc::gi::Delaunay(*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_gi_Delaunay, __jsb_cc_gi_Delaunay_class, js_delete_cc_gi_Delaunay)

static bool js_delete_cc_gi_Delaunay(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_Delaunay) 

static bool js_cc_gi_Delaunay_build(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::Delaunay *arg1 = (cc::gi::Delaunay *) NULL ;
    ccstd::vector< cc::gi::Tetrahedron > result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::Delaunay>(s);
    if (nullptr == arg1) return true;
    result = (arg1)->build();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_Delaunay_build) 

bool js_register_cc_gi_Delaunay(se::Object* obj) {
    auto* cls = se::Class::create("Delaunay", obj, nullptr, _SE(js_new_cc_gi_Delaunay)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("build", _SE(js_cc_gi_Delaunay_build)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_gi_Delaunay));
    
    
    cls->install();
    JSBClassType::registerClass<cc::gi::Delaunay>(cls);
    
    __jsb_cc_gi_Delaunay_proto = cls->getProto();
    __jsb_cc_gi_Delaunay_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_gi_LightProbesData_class = nullptr;
se::Object* __jsb_cc_gi_LightProbesData_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_LightProbesData) 

static bool js_new_cc_gi_LightProbesData(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    cc::gi::LightProbesData *result;
    result = (cc::gi::LightProbesData *)new cc::gi::LightProbesData();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_gi_LightProbesData, __jsb_cc_gi_LightProbesData_class, js_delete_cc_gi_LightProbesData)

static bool js_cc_gi_LightProbesData_empty(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    bool result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::gi::LightProbesData const *)arg1)->empty();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbesData_empty) 

static bool js_cc_gi_LightProbesData_reset(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    (arg1)->reset();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbesData_reset) 

static bool js_cc_gi_LightProbesData_updateProbes(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    ccstd::vector< Vec3 > *arg2 = 0 ;
    ccstd::vector< Vec3 > temp2 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    (arg1)->updateProbes(*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbesData_updateProbes) 

static bool js_cc_gi_LightProbesData_updateTetrahedrons(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    (arg1)->updateTetrahedrons();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbesData_updateTetrahedrons) 

static bool js_cc_gi_LightProbesData_hasCoefficients(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    bool result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::gi::LightProbesData const *)arg1)->hasCoefficients();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbesData_hasCoefficients) 

static bool js_cc_gi_LightProbesData_getInterpolationSHCoefficients(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    int32_t arg2 ;
    Vec4 *arg3 = 0 ;
    ccstd::vector< Vec3 > *arg4 = 0 ;
    Vec4 temp3 ;
    ccstd::vector< Vec3 > temp4 ;
    bool result;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    
    ok &= sevalue_to_native(args[2], &temp4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg4 = &temp4;
    
    result = (bool)((cc::gi::LightProbesData const *)arg1)->getInterpolationSHCoefficients(arg2,(Vec4 const &)*arg3,*arg4);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbesData_getInterpolationSHCoefficients) 

static bool js_cc_gi_LightProbesData_getInterpolationWeights(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    Vec3 *arg2 = 0 ;
    int32_t arg3 ;
    Vec4 *arg4 = 0 ;
    Vec3 temp2 ;
    Vec4 temp4 ;
    int32_t result;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &temp4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg4 = &temp4;
    
    result = ((cc::gi::LightProbesData const *)arg1)->getInterpolationWeights((Vec3 const &)*arg2,arg3,*arg4);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbesData_getInterpolationWeights) 

static bool js_cc_gi_LightProbesData__probes_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_probes, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbesData__probes_set) 

static bool js_cc_gi_LightProbesData__probes_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_probes, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_probes, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbesData__probes_get) 

static bool js_cc_gi_LightProbesData__tetrahedrons_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_tetrahedrons, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbesData__tetrahedrons_set) 

static bool js_cc_gi_LightProbesData__tetrahedrons_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_tetrahedrons, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_tetrahedrons, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbesData__tetrahedrons_get) 

static bool js_cc_gi_LightProbesData_probes_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    ccstd::vector< cc::gi::Vertex > *arg2 = 0 ;
    ccstd::vector< cc::gi::Vertex > temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_gi_LightProbesData_probes_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbesData_probes_set) 

static bool js_cc_gi_LightProbesData_probes_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    ccstd::vector< cc::gi::Vertex > *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    result = (ccstd::vector< cc::gi::Vertex > *) &cc_gi_LightProbesData_probes_get(arg1);
    
    ok &= nativevalue_to_se(*result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbesData_probes_get) 

static bool js_cc_gi_LightProbesData_tetrahedrons_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    ccstd::vector< cc::gi::Tetrahedron > *arg2 = 0 ;
    ccstd::vector< cc::gi::Tetrahedron > temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_gi_LightProbesData_tetrahedrons_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbesData_tetrahedrons_set) 

static bool js_cc_gi_LightProbesData_tetrahedrons_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ;
    ccstd::vector< cc::gi::Tetrahedron > *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbesData>(s);
    if (nullptr == arg1) return true;
    result = (ccstd::vector< cc::gi::Tetrahedron > *) &cc_gi_LightProbesData_tetrahedrons_get(arg1);
    
    ok &= nativevalue_to_se(*result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbesData_tetrahedrons_get) 

static bool js_delete_cc_gi_LightProbesData(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_LightProbesData) 

bool js_register_cc_gi_LightProbesData(se::Object* obj) {
    auto* cls = se::Class::create("LightProbesData", obj, nullptr, _SE(js_new_cc_gi_LightProbesData)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("_probes", _SE(js_cc_gi_LightProbesData__probes_get), _SE(js_cc_gi_LightProbesData__probes_set)); 
    cls->defineProperty("_tetrahedrons", _SE(js_cc_gi_LightProbesData__tetrahedrons_get), _SE(js_cc_gi_LightProbesData__tetrahedrons_set)); 
    cls->defineProperty("probes", _SE(js_cc_gi_LightProbesData_probes_get), _SE(js_cc_gi_LightProbesData_probes_set)); 
    cls->defineProperty("tetrahedrons", _SE(js_cc_gi_LightProbesData_tetrahedrons_get), _SE(js_cc_gi_LightProbesData_tetrahedrons_set)); 
    
    cls->defineFunction("empty", _SE(js_cc_gi_LightProbesData_empty)); 
    cls->defineFunction("reset", _SE(js_cc_gi_LightProbesData_reset)); 
    cls->defineFunction("updateProbes", _SE(js_cc_gi_LightProbesData_updateProbes)); 
    cls->defineFunction("updateTetrahedrons", _SE(js_cc_gi_LightProbesData_updateTetrahedrons)); 
    cls->defineFunction("hasCoefficients", _SE(js_cc_gi_LightProbesData_hasCoefficients)); 
    cls->defineFunction("getInterpolationSHCoefficients", _SE(js_cc_gi_LightProbesData_getInterpolationSHCoefficients)); 
    cls->defineFunction("getInterpolationWeights", _SE(js_cc_gi_LightProbesData_getInterpolationWeights)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_gi_LightProbesData));
    
    
    cls->install();
    JSBClassType::registerClass<cc::gi::LightProbesData>(cls);
    
    __jsb_cc_gi_LightProbesData_proto = cls->getProto();
    __jsb_cc_gi_LightProbesData_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_gi_LightProbes_class = nullptr;
se::Object* __jsb_cc_gi_LightProbes_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_LightProbes) 

static bool js_new_cc_gi_LightProbes(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    cc::gi::LightProbes *result;
    result = (cc::gi::LightProbes *)new cc::gi::LightProbes();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_gi_LightProbes, __jsb_cc_gi_LightProbes_class, js_delete_cc_gi_LightProbes)

static bool js_delete_cc_gi_LightProbes(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_LightProbes) 

static bool js_cc_gi_LightProbes_initialize(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    cc::gi::LightProbeInfo *arg2 = (cc::gi::LightProbeInfo *) NULL ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->initialize(arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbes_initialize) 

static bool js_cc_gi_LightProbes_empty(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    bool result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::gi::LightProbes const *)arg1)->empty();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbes_empty) 

static bool js_cc_gi_LightProbes__giScale_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_giScale, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes__giScale_set) 

static bool js_cc_gi_LightProbes__giScale_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_giScale, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes__giScale_get) 

static bool js_cc_gi_LightProbes__lightProbeSphereVolume_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_lightProbeSphereVolume, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes__lightProbeSphereVolume_set) 

static bool js_cc_gi_LightProbes__lightProbeSphereVolume_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_lightProbeSphereVolume, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes__lightProbeSphereVolume_get) 

static bool js_cc_gi_LightProbes__giSamples_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_giSamples, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes__giSamples_set) 

static bool js_cc_gi_LightProbes__giSamples_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_giSamples, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes__giSamples_get) 

static bool js_cc_gi_LightProbes__bounces_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_bounces, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes__bounces_set) 

static bool js_cc_gi_LightProbes__bounces_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_bounces, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes__bounces_get) 

static bool js_cc_gi_LightProbes__reduceRinging_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_reduceRinging, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes__reduceRinging_set) 

static bool js_cc_gi_LightProbes__reduceRinging_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_reduceRinging, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes__reduceRinging_get) 

static bool js_cc_gi_LightProbes__showProbe_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_showProbe);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes__showProbe_set) 

static bool js_cc_gi_LightProbes__showProbe_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_showProbe, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes__showProbe_get) 

static bool js_cc_gi_LightProbes__showWireframe_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_showWireframe);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes__showWireframe_set) 

static bool js_cc_gi_LightProbes__showWireframe_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_showWireframe, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes__showWireframe_get) 

static bool js_cc_gi_LightProbes__showConvex_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_showConvex);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes__showConvex_set) 

static bool js_cc_gi_LightProbes__showConvex_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_showConvex, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes__showConvex_get) 

static bool js_cc_gi_LightProbes__data_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_data, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes__data_set) 

static bool js_cc_gi_LightProbes__data_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_data, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_data, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes__data_get) 

static bool js_cc_gi_LightProbes_giScale_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    float arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbes_giScale_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes_giScale_set) 

static bool js_cc_gi_LightProbes_giScale_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    float result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    result = (float)cc_gi_LightProbes_giScale_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes_giScale_get) 

static bool js_cc_gi_LightProbes_giSamples_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    uint32_t arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    cc_gi_LightProbes_giSamples_set(arg1,SWIG_STD_MOVE(arg2));
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes_giSamples_set) 

static bool js_cc_gi_LightProbes_giSamples_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    result = cc_gi_LightProbes_giSamples_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes_giSamples_get) 

static bool js_cc_gi_LightProbes_bounces_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    uint32_t arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    cc_gi_LightProbes_bounces_set(arg1,SWIG_STD_MOVE(arg2));
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes_bounces_set) 

static bool js_cc_gi_LightProbes_bounces_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    result = cc_gi_LightProbes_bounces_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes_bounces_get) 

static bool js_cc_gi_LightProbes_reduceRinging_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    float arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbes_reduceRinging_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes_reduceRinging_set) 

static bool js_cc_gi_LightProbes_reduceRinging_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    float result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    result = (float)cc_gi_LightProbes_reduceRinging_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes_reduceRinging_get) 

static bool js_cc_gi_LightProbes_showProbe_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    bool arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbes_showProbe_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes_showProbe_set) 

static bool js_cc_gi_LightProbes_showProbe_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    result = (bool)cc_gi_LightProbes_showProbe_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes_showProbe_get) 

static bool js_cc_gi_LightProbes_showWireframe_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    bool arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbes_showWireframe_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes_showWireframe_set) 

static bool js_cc_gi_LightProbes_showWireframe_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    result = (bool)cc_gi_LightProbes_showWireframe_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes_showWireframe_get) 

static bool js_cc_gi_LightProbes_lightProbeSphereVolume_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    float arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbes_lightProbeSphereVolume_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes_lightProbeSphereVolume_set) 

static bool js_cc_gi_LightProbes_lightProbeSphereVolume_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    float result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    result = (float)cc_gi_LightProbes_lightProbeSphereVolume_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes_lightProbeSphereVolume_get) 

static bool js_cc_gi_LightProbes_showConvex_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    bool arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbes_showConvex_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes_showConvex_set) 

static bool js_cc_gi_LightProbes_showConvex_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    result = (bool)cc_gi_LightProbes_showConvex_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes_showConvex_get) 

static bool js_cc_gi_LightProbes_data_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    cc::gi::LightProbesData *arg2 = (cc::gi::LightProbesData *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbes_data_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbes_data_set) 

static bool js_cc_gi_LightProbes_data_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ;
    cc::gi::LightProbesData *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbes>(s);
    if (nullptr == arg1) return true;
    result = (cc::gi::LightProbesData *)cc_gi_LightProbes_data_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbes_data_get) 

bool js_register_cc_gi_LightProbes(se::Object* obj) {
    auto* cls = se::Class::create("LightProbes", obj, nullptr, _SE(js_new_cc_gi_LightProbes)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("_giScale", _SE(js_cc_gi_LightProbes__giScale_get), _SE(js_cc_gi_LightProbes__giScale_set)); 
    cls->defineProperty("_lightProbeSphereVolume", _SE(js_cc_gi_LightProbes__lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbes__lightProbeSphereVolume_set)); 
    cls->defineProperty("_giSamples", _SE(js_cc_gi_LightProbes__giSamples_get), _SE(js_cc_gi_LightProbes__giSamples_set)); 
    cls->defineProperty("_bounces", _SE(js_cc_gi_LightProbes__bounces_get), _SE(js_cc_gi_LightProbes__bounces_set)); 
    cls->defineProperty("_reduceRinging", _SE(js_cc_gi_LightProbes__reduceRinging_get), _SE(js_cc_gi_LightProbes__reduceRinging_set)); 
    cls->defineProperty("_showProbe", _SE(js_cc_gi_LightProbes__showProbe_get), _SE(js_cc_gi_LightProbes__showProbe_set)); 
    cls->defineProperty("_showWireframe", _SE(js_cc_gi_LightProbes__showWireframe_get), _SE(js_cc_gi_LightProbes__showWireframe_set)); 
    cls->defineProperty("_showConvex", _SE(js_cc_gi_LightProbes__showConvex_get), _SE(js_cc_gi_LightProbes__showConvex_set)); 
    cls->defineProperty("_data", _SE(js_cc_gi_LightProbes__data_get), _SE(js_cc_gi_LightProbes__data_set)); 
    cls->defineProperty("giScale", _SE(js_cc_gi_LightProbes_giScale_get), _SE(js_cc_gi_LightProbes_giScale_set)); 
    cls->defineProperty("giSamples", _SE(js_cc_gi_LightProbes_giSamples_get), _SE(js_cc_gi_LightProbes_giSamples_set)); 
    cls->defineProperty("bounces", _SE(js_cc_gi_LightProbes_bounces_get), _SE(js_cc_gi_LightProbes_bounces_set)); 
    cls->defineProperty("reduceRinging", _SE(js_cc_gi_LightProbes_reduceRinging_get), _SE(js_cc_gi_LightProbes_reduceRinging_set)); 
    cls->defineProperty("showProbe", _SE(js_cc_gi_LightProbes_showProbe_get), _SE(js_cc_gi_LightProbes_showProbe_set)); 
    cls->defineProperty("showWireframe", _SE(js_cc_gi_LightProbes_showWireframe_get), _SE(js_cc_gi_LightProbes_showWireframe_set)); 
    cls->defineProperty("lightProbeSphereVolume", _SE(js_cc_gi_LightProbes_lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbes_lightProbeSphereVolume_set)); 
    cls->defineProperty("showConvex", _SE(js_cc_gi_LightProbes_showConvex_get), _SE(js_cc_gi_LightProbes_showConvex_set)); 
    cls->defineProperty("data", _SE(js_cc_gi_LightProbes_data_get), _SE(js_cc_gi_LightProbes_data_set)); 
    
    cls->defineFunction("initialize", _SE(js_cc_gi_LightProbes_initialize)); 
    cls->defineFunction("empty", _SE(js_cc_gi_LightProbes_empty)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_gi_LightProbes));
    
    
    cls->install();
    JSBClassType::registerClass<cc::gi::LightProbes>(cls);
    
    __jsb_cc_gi_LightProbes_proto = cls->getProto();
    __jsb_cc_gi_LightProbes_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_gi_LightProbeInfo_class = nullptr;
se::Object* __jsb_cc_gi_LightProbeInfo_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_LightProbeInfo) 

static bool js_new_cc_gi_LightProbeInfo(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    cc::gi::LightProbeInfo *result;
    result = (cc::gi::LightProbeInfo *)new cc::gi::LightProbeInfo();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_gi_LightProbeInfo, __jsb_cc_gi_LightProbeInfo_class, js_delete_cc_gi_LightProbeInfo)

static bool js_delete_cc_gi_LightProbeInfo(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_LightProbeInfo) 

static bool js_cc_gi_LightProbeInfo_activate(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    cc::Scene *arg2 = (cc::Scene *) NULL ;
    cc::gi::LightProbes *arg3 = (cc::gi::LightProbes *) NULL ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->activate(arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbeInfo_activate) 

static bool js_cc_gi_LightProbeInfo_onProbeBakeFinished(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    (arg1)->onProbeBakeFinished();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbeInfo_onProbeBakeFinished) 

static bool js_cc_gi_LightProbeInfo_onProbeBakeCleared(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    (arg1)->onProbeBakeCleared();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbeInfo_onProbeBakeCleared) 

static bool js_cc_gi_LightProbeInfo_clearSHCoefficients(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    (arg1)->clearSHCoefficients();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbeInfo_clearSHCoefficients) 

static bool js_cc_gi_LightProbeInfo_isUniqueNode(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    bool result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::gi::LightProbeInfo const *)arg1)->isUniqueNode();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbeInfo_isUniqueNode) 

static bool js_cc_gi_LightProbeInfo_addNode(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    cc::Node *arg2 = (cc::Node *) NULL ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (bool)(arg1)->addNode(arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbeInfo_addNode) 

static bool js_cc_gi_LightProbeInfo_removeNode(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    cc::Node *arg2 = (cc::Node *) NULL ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (bool)(arg1)->removeNode(arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbeInfo_removeNode) 

static bool js_cc_gi_LightProbeInfo_syncData(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    cc::Node *arg2 = (cc::Node *) NULL ;
    ccstd::vector< Vec3 > *arg3 = 0 ;
    ccstd::vector< Vec3 > temp3 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    (arg1)->syncData(arg2,(ccstd::vector< Vec3 > const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_gi_LightProbeInfo_syncData) 

static bool js_cc_gi_LightProbeInfo_update__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    bool arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->update(arg2);
    
    
    return true;
}

static bool js_cc_gi_LightProbeInfo_update__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    (arg1)->update();
    
    
    return true;
}

static bool js_cc_gi_LightProbeInfo_update(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 1) {
        ok = js_cc_gi_LightProbeInfo_update__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 0) {
        ok = js_cc_gi_LightProbeInfo_update__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_gi_LightProbeInfo_update) 

static bool js_cc_gi_LightProbeInfo__giScale_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_giScale, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__giScale_set) 

static bool js_cc_gi_LightProbeInfo__giScale_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_giScale, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__giScale_get) 

static bool js_cc_gi_LightProbeInfo__lightProbeSphereVolume_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_lightProbeSphereVolume, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_set) 

static bool js_cc_gi_LightProbeInfo__lightProbeSphereVolume_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_lightProbeSphereVolume, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_get) 

static bool js_cc_gi_LightProbeInfo__giSamples_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_giSamples, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__giSamples_set) 

static bool js_cc_gi_LightProbeInfo__giSamples_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_giSamples, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__giSamples_get) 

static bool js_cc_gi_LightProbeInfo__bounces_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_bounces, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__bounces_set) 

static bool js_cc_gi_LightProbeInfo__bounces_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_bounces, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__bounces_get) 

static bool js_cc_gi_LightProbeInfo__reduceRinging_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_reduceRinging, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__reduceRinging_set) 

static bool js_cc_gi_LightProbeInfo__reduceRinging_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_reduceRinging, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__reduceRinging_get) 

static bool js_cc_gi_LightProbeInfo__showProbe_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_showProbe);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__showProbe_set) 

static bool js_cc_gi_LightProbeInfo__showProbe_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_showProbe, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__showProbe_get) 

static bool js_cc_gi_LightProbeInfo__showWireframe_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_showWireframe);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__showWireframe_set) 

static bool js_cc_gi_LightProbeInfo__showWireframe_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_showWireframe, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__showWireframe_get) 

static bool js_cc_gi_LightProbeInfo__showConvex_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_showConvex);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__showConvex_set) 

static bool js_cc_gi_LightProbeInfo__showConvex_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_showConvex, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__showConvex_get) 

static bool js_cc_gi_LightProbeInfo__data_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_data, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__data_set) 

static bool js_cc_gi_LightProbeInfo__data_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_data, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_data, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__data_get) 

static bool js_cc_gi_LightProbeInfo_giScale_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    float arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbeInfo_giScale_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_giScale_set) 

static bool js_cc_gi_LightProbeInfo_giScale_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    float result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    result = (float)cc_gi_LightProbeInfo_giScale_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_giScale_get) 

static bool js_cc_gi_LightProbeInfo_giSamples_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    uint32_t arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    cc_gi_LightProbeInfo_giSamples_set(arg1,SWIG_STD_MOVE(arg2));
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_giSamples_set) 

static bool js_cc_gi_LightProbeInfo_giSamples_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    result = cc_gi_LightProbeInfo_giSamples_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_giSamples_get) 

static bool js_cc_gi_LightProbeInfo_bounces_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    uint32_t arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    cc_gi_LightProbeInfo_bounces_set(arg1,SWIG_STD_MOVE(arg2));
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_bounces_set) 

static bool js_cc_gi_LightProbeInfo_bounces_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    result = cc_gi_LightProbeInfo_bounces_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_bounces_get) 

static bool js_cc_gi_LightProbeInfo_lightProbeSphereVolume_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    float arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbeInfo_lightProbeSphereVolume_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_set) 

static bool js_cc_gi_LightProbeInfo_lightProbeSphereVolume_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    float result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    result = (float)cc_gi_LightProbeInfo_lightProbeSphereVolume_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_get) 

static bool js_cc_gi_LightProbeInfo_reduceRinging_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    float arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbeInfo_reduceRinging_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_reduceRinging_set) 

static bool js_cc_gi_LightProbeInfo_reduceRinging_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    float result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    result = (float)cc_gi_LightProbeInfo_reduceRinging_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_reduceRinging_get) 

static bool js_cc_gi_LightProbeInfo_showProbe_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    bool arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbeInfo_showProbe_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_showProbe_set) 

static bool js_cc_gi_LightProbeInfo_showProbe_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    result = (bool)cc_gi_LightProbeInfo_showProbe_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_showProbe_get) 

static bool js_cc_gi_LightProbeInfo_showWireframe_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    bool arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbeInfo_showWireframe_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_showWireframe_set) 

static bool js_cc_gi_LightProbeInfo_showWireframe_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    result = (bool)cc_gi_LightProbeInfo_showWireframe_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_showWireframe_get) 

static bool js_cc_gi_LightProbeInfo_showConvex_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    bool arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbeInfo_showConvex_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_showConvex_set) 

static bool js_cc_gi_LightProbeInfo_showConvex_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    result = (bool)cc_gi_LightProbeInfo_showConvex_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_showConvex_get) 

static bool js_cc_gi_LightProbeInfo_data_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    cc::gi::LightProbesData *arg2 = (cc::gi::LightProbesData *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_gi_LightProbeInfo_data_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_data_set) 

static bool js_cc_gi_LightProbeInfo_data_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ;
    cc::gi::LightProbesData *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::gi::LightProbeInfo>(s);
    if (nullptr == arg1) return true;
    result = (cc::gi::LightProbesData *)cc_gi_LightProbeInfo_data_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_data_get) 

bool js_register_cc_gi_LightProbeInfo(se::Object* obj) {
    auto* cls = se::Class::create("LightProbeInfo", obj, nullptr, _SE(js_new_cc_gi_LightProbeInfo)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("_giScale", _SE(js_cc_gi_LightProbeInfo__giScale_get), _SE(js_cc_gi_LightProbeInfo__giScale_set)); 
    cls->defineProperty("_lightProbeSphereVolume", _SE(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_set)); 
    cls->defineProperty("_giSamples", _SE(js_cc_gi_LightProbeInfo__giSamples_get), _SE(js_cc_gi_LightProbeInfo__giSamples_set)); 
    cls->defineProperty("_bounces", _SE(js_cc_gi_LightProbeInfo__bounces_get), _SE(js_cc_gi_LightProbeInfo__bounces_set)); 
    cls->defineProperty("_reduceRinging", _SE(js_cc_gi_LightProbeInfo__reduceRinging_get), _SE(js_cc_gi_LightProbeInfo__reduceRinging_set)); 
    cls->defineProperty("_showProbe", _SE(js_cc_gi_LightProbeInfo__showProbe_get), _SE(js_cc_gi_LightProbeInfo__showProbe_set)); 
    cls->defineProperty("_showWireframe", _SE(js_cc_gi_LightProbeInfo__showWireframe_get), _SE(js_cc_gi_LightProbeInfo__showWireframe_set)); 
    cls->defineProperty("_showConvex", _SE(js_cc_gi_LightProbeInfo__showConvex_get), _SE(js_cc_gi_LightProbeInfo__showConvex_set)); 
    cls->defineProperty("_data", _SE(js_cc_gi_LightProbeInfo__data_get), _SE(js_cc_gi_LightProbeInfo__data_set)); 
    cls->defineProperty("giScale", _SE(js_cc_gi_LightProbeInfo_giScale_get), _SE(js_cc_gi_LightProbeInfo_giScale_set)); 
    cls->defineProperty("giSamples", _SE(js_cc_gi_LightProbeInfo_giSamples_get), _SE(js_cc_gi_LightProbeInfo_giSamples_set)); 
    cls->defineProperty("bounces", _SE(js_cc_gi_LightProbeInfo_bounces_get), _SE(js_cc_gi_LightProbeInfo_bounces_set)); 
    cls->defineProperty("lightProbeSphereVolume", _SE(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_set)); 
    cls->defineProperty("reduceRinging", _SE(js_cc_gi_LightProbeInfo_reduceRinging_get), _SE(js_cc_gi_LightProbeInfo_reduceRinging_set)); 
    cls->defineProperty("showProbe", _SE(js_cc_gi_LightProbeInfo_showProbe_get), _SE(js_cc_gi_LightProbeInfo_showProbe_set)); 
    cls->defineProperty("showWireframe", _SE(js_cc_gi_LightProbeInfo_showWireframe_get), _SE(js_cc_gi_LightProbeInfo_showWireframe_set)); 
    cls->defineProperty("showConvex", _SE(js_cc_gi_LightProbeInfo_showConvex_get), _SE(js_cc_gi_LightProbeInfo_showConvex_set)); 
    cls->defineProperty("data", _SE(js_cc_gi_LightProbeInfo_data_get), _SE(js_cc_gi_LightProbeInfo_data_set)); 
    
    cls->defineFunction("activate", _SE(js_cc_gi_LightProbeInfo_activate)); 
    cls->defineFunction("onProbeBakeFinished", _SE(js_cc_gi_LightProbeInfo_onProbeBakeFinished)); 
    cls->defineFunction("onProbeBakeCleared", _SE(js_cc_gi_LightProbeInfo_onProbeBakeCleared)); 
    cls->defineFunction("clearSHCoefficients", _SE(js_cc_gi_LightProbeInfo_clearSHCoefficients)); 
    cls->defineFunction("isUniqueNode", _SE(js_cc_gi_LightProbeInfo_isUniqueNode)); 
    cls->defineFunction("addNode", _SE(js_cc_gi_LightProbeInfo_addNode)); 
    cls->defineFunction("removeNode", _SE(js_cc_gi_LightProbeInfo_removeNode)); 
    cls->defineFunction("syncData", _SE(js_cc_gi_LightProbeInfo_syncData)); 
    cls->defineFunction("update", _SE(js_cc_gi_LightProbeInfo_update)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_gi_LightProbeInfo));
    
    
    cls->install();
    JSBClassType::registerClass<cc::gi::LightProbeInfo>(cls);
    
    __jsb_cc_gi_LightProbeInfo_proto = cls->getProto();
    __jsb_cc_gi_LightProbeInfo_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}




bool register_all_gi(se::Object* obj) {
    // Get the ns
    se::Value nsVal;
    if (!obj->getProperty("jsb", &nsVal, true))
    {
        se::HandleObject jsobj(se::Object::createPlainObject());
        nsVal.setObject(jsobj);
        obj->setProperty("jsb", nsVal);
    }
    se::Object* ns = nsVal.toObject();
    /* Register classes */
    js_register_cc_gi_Vertex(ns); 
    js_register_cc_gi_CircumSphere(ns); 
    js_register_cc_gi_Tetrahedron(ns); 
    js_register_cc_gi_Delaunay(ns); 
    js_register_cc_gi_LightProbesData(ns); 
    js_register_cc_gi_LightProbes(ns); 
    js_register_cc_gi_LightProbeInfo(ns); 
    
    /* Register global variables & global functions */
    
    
    
    return true;
}


#if defined(__clang__)
#pragma clang diagnostic pop
#elif defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic pop
#elif defined(_MSC_VER)
#pragma warning(pop)
#endif
// clang-format on
