// 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_render_auto.h"
#include "bindings/auto/jsb_scene_auto.h"
#include "bindings/auto/jsb_gfx_auto.h"
#include "bindings/auto/jsb_assets_auto.h"
#include "renderer/pipeline/GeometryRenderer.h"
#include "renderer/pipeline/GlobalDescriptorSetManager.h"
#include "renderer/pipeline/custom/RenderCommonJsb.h"

using namespace cc;
using namespace cc::render;


#define cc_render_PipelineRuntime_device_get(self_) self_->getDevice()
  

#define cc_render_PipelineRuntime_macros_get(self_) self_->getMacros()
  

#define cc_render_PipelineRuntime_globalDSManager_get(self_) self_->getGlobalDSManager()
  

#define cc_render_PipelineRuntime_descriptorSetLayout_get(self_) self_->getDescriptorSetLayout()
  

#define cc_render_PipelineRuntime_descriptorSet_get(self_) self_->getDescriptorSet()
  

#define cc_render_PipelineRuntime_commandBuffers_get(self_) self_->getCommandBuffers()
  

#define cc_render_PipelineRuntime_pipelineSceneData_get(self_) self_->getPipelineSceneData()
  

#define cc_render_PipelineRuntime_constantMacros_get(self_) self_->getConstantMacros()
  

#define cc_render_PipelineRuntime_profiler_get(self_) self_->getProfiler()
#define cc_render_PipelineRuntime_profiler_set(self_, val_) self_->setProfiler(val_)
  

#define cc_render_PipelineRuntime_geometryRenderer_get(self_) self_->getGeometryRenderer()
  

#define cc_render_PipelineRuntime_shadingScale_get(self_) self_->getShadingScale()
#define cc_render_PipelineRuntime_shadingScale_set(self_, val_) self_->setShadingScale(val_)
  

#define cc_render_RenderNode_name_get(self_) self_->getName()
#define cc_render_RenderNode_name_set(self_, val_) self_->setName(val_)
  

#define cc_render_BasicRenderPassBuilder_showStatistics_get(self_) self_->getShowStatistics()
#define cc_render_BasicRenderPassBuilder_showStatistics_set(self_, val_) self_->setShowStatistics(val_)
  

#define cc_render_BasicPipeline_type_get(self_) self_->getType()
  

#define cc_render_BasicPipeline_capabilities_get(self_) self_->getCapabilities()
  

#define cc_render_BasicPipeline_enableCpuLightCulling_get(self_) self_->getEnableCpuLightCulling()
#define cc_render_BasicPipeline_enableCpuLightCulling_set(self_, val_) self_->setEnableCpuLightCulling(val_)
  

#define cc_render_RenderSubpassBuilder_showStatistics_get(self_) self_->getShowStatistics()
#define cc_render_RenderSubpassBuilder_showStatistics_set(self_, val_) self_->setShowStatistics(val_)
  


se::Class* __jsb_cc_render_PipelineRuntime_class = nullptr;
se::Object* __jsb_cc_render_PipelineRuntime_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelineRuntime) 

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

static bool js_cc_render_PipelineRuntime_activate(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    gfx::Swapchain *arg2 = (gfx::Swapchain *) 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::render::PipelineRuntime>(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)->activate(arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineRuntime_activate) 

static bool js_cc_render_PipelineRuntime_destroy(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) 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::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (bool)(arg1)->destroy();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineRuntime_destroy) 

static bool js_cc_render_PipelineRuntime_render(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    ccstd::vector< cc::scene::Camera * > *arg2 = 0 ;
    ccstd::vector< cc::scene::Camera * > 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::render::PipelineRuntime>(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)->render((ccstd::vector< cc::scene::Camera * > const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineRuntime_render) 

static bool js_cc_render_PipelineRuntime_getMacroString(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    ccstd::string *result = 0 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(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 = (ccstd::string *) &((cc::render::PipelineRuntime const *)arg1)->getMacroString((ccstd::string const &)*arg2);
    
    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_FUNC(js_cc_render_PipelineRuntime_getMacroString) 

static bool js_cc_render_PipelineRuntime_getMacroInt(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    int32_t 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::render::PipelineRuntime>(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 = ((cc::render::PipelineRuntime const *)arg1)->getMacroInt((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineRuntime_getMacroInt) 

static bool js_cc_render_PipelineRuntime_getMacroBool(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string 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::render::PipelineRuntime>(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::render::PipelineRuntime const *)arg1)->getMacroBool((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineRuntime_getMacroBool) 

static bool js_cc_render_PipelineRuntime_setMacroString(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string 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::render::PipelineRuntime>(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;
    
    (arg1)->setMacroString((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineRuntime_setMacroString) 

static bool js_cc_render_PipelineRuntime_setMacroInt(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    ccstd::string *arg2 = 0 ;
    int32_t arg3 ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(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"); 
    (arg1)->setMacroInt((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineRuntime_setMacroInt) 

static bool js_cc_render_PipelineRuntime_setMacroBool(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    ccstd::string *arg2 = 0 ;
    bool arg3 ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(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);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->setMacroBool((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineRuntime_setMacroBool) 

static bool js_cc_render_PipelineRuntime_onGlobalPipelineStateChanged(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) 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::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    (arg1)->onGlobalPipelineStateChanged();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineRuntime_onGlobalPipelineStateChanged) 

static bool js_cc_render_PipelineRuntime_device_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    cc::gfx::Device *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (cc::gfx::Device *)cc_render_PipelineRuntime_device_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_render_PipelineRuntime_device_get) 

static bool js_cc_render_PipelineRuntime_macros_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    cc::MacroRecord *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (cc::MacroRecord *) &cc_render_PipelineRuntime_macros_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_render_PipelineRuntime_macros_get) 

static bool js_cc_render_PipelineRuntime_globalDSManager_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    cc::pipeline::GlobalDSManager *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (cc::pipeline::GlobalDSManager *)cc_render_PipelineRuntime_globalDSManager_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_render_PipelineRuntime_globalDSManager_get) 

static bool js_cc_render_PipelineRuntime_descriptorSetLayout_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    cc::gfx::DescriptorSetLayout *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (cc::gfx::DescriptorSetLayout *)cc_render_PipelineRuntime_descriptorSetLayout_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_render_PipelineRuntime_descriptorSetLayout_get) 

static bool js_cc_render_PipelineRuntime_descriptorSet_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    cc::gfx::DescriptorSet *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (cc::gfx::DescriptorSet *)cc_render_PipelineRuntime_descriptorSet_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_render_PipelineRuntime_descriptorSet_get) 

static bool js_cc_render_PipelineRuntime_commandBuffers_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    ccstd::vector< cc::gfx::CommandBuffer * > *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (ccstd::vector< cc::gfx::CommandBuffer * > *) &cc_render_PipelineRuntime_commandBuffers_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_render_PipelineRuntime_commandBuffers_get) 

static bool js_cc_render_PipelineRuntime_pipelineSceneData_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    cc::pipeline::PipelineSceneData *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (cc::pipeline::PipelineSceneData *)cc_render_PipelineRuntime_pipelineSceneData_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_render_PipelineRuntime_pipelineSceneData_get) 

static bool js_cc_render_PipelineRuntime_constantMacros_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    ccstd::string *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (ccstd::string *) &cc_render_PipelineRuntime_constantMacros_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_render_PipelineRuntime_constantMacros_get) 

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

static bool js_cc_render_PipelineRuntime_profiler_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    cc::scene::Model *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (cc::scene::Model *)cc_render_PipelineRuntime_profiler_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_render_PipelineRuntime_profiler_get) 

static bool js_cc_render_PipelineRuntime_geometryRenderer_get(se::State& s)
{
#if CC_USE_GEOMETRY_RENDERER
    
    CC_UNUSED bool ok = true;
    cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ;
    cc::pipeline::GeometryRenderer *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::PipelineRuntime>(s);
    if (nullptr == arg1) return true;
    result = (cc::pipeline::GeometryRenderer *)cc_render_PipelineRuntime_geometryRenderer_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()); 
    
#endif // CC_USE_GEOMETRY_RENDERER
    
    return true;
}
SE_BIND_PROP_GET(js_cc_render_PipelineRuntime_geometryRenderer_get) 

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

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

bool js_register_cc_render_PipelineRuntime(se::Object* obj) {
    auto* cls = se::Class::create("PipelineRuntime", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("device", _SE(js_cc_render_PipelineRuntime_device_get), nullptr); 
    cls->defineProperty("macros", _SE(js_cc_render_PipelineRuntime_macros_get), nullptr); 
    cls->defineProperty("globalDSManager", _SE(js_cc_render_PipelineRuntime_globalDSManager_get), nullptr); 
    cls->defineProperty("descriptorSetLayout", _SE(js_cc_render_PipelineRuntime_descriptorSetLayout_get), nullptr); 
    cls->defineProperty("descriptorSet", _SE(js_cc_render_PipelineRuntime_descriptorSet_get), nullptr); 
    cls->defineProperty("commandBuffers", _SE(js_cc_render_PipelineRuntime_commandBuffers_get), nullptr); 
    cls->defineProperty("pipelineSceneData", _SE(js_cc_render_PipelineRuntime_pipelineSceneData_get), nullptr); 
    cls->defineProperty("constantMacros", _SE(js_cc_render_PipelineRuntime_constantMacros_get), nullptr); 
    cls->defineProperty("profiler", _SE(js_cc_render_PipelineRuntime_profiler_get), _SE(js_cc_render_PipelineRuntime_profiler_set)); 
    cls->defineProperty("geometryRenderer", _SE(js_cc_render_PipelineRuntime_geometryRenderer_get), nullptr); 
    cls->defineProperty("shadingScale", _SE(js_cc_render_PipelineRuntime_shadingScale_get), _SE(js_cc_render_PipelineRuntime_shadingScale_set)); 
    
    cls->defineFunction("activate", _SE(js_cc_render_PipelineRuntime_activate)); 
    cls->defineFunction("destroy", _SE(js_cc_render_PipelineRuntime_destroy)); 
    cls->defineFunction("render", _SE(js_cc_render_PipelineRuntime_render)); 
    cls->defineFunction("getMacroString", _SE(js_cc_render_PipelineRuntime_getMacroString)); 
    cls->defineFunction("getMacroInt", _SE(js_cc_render_PipelineRuntime_getMacroInt)); 
    cls->defineFunction("getMacroBool", _SE(js_cc_render_PipelineRuntime_getMacroBool)); 
    cls->defineFunction("setMacroString", _SE(js_cc_render_PipelineRuntime_setMacroString)); 
    cls->defineFunction("setMacroInt", _SE(js_cc_render_PipelineRuntime_setMacroInt)); 
    cls->defineFunction("setMacroBool", _SE(js_cc_render_PipelineRuntime_setMacroBool)); 
    cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_render_PipelineRuntime_onGlobalPipelineStateChanged)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_PipelineRuntime));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::PipelineRuntime>(cls);
    
    __jsb_cc_render_PipelineRuntime_proto = cls->getProto();
    __jsb_cc_render_PipelineRuntime_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


static bool js_cc_render_any(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::SubpassCapabilities arg1 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (bool)cc::render::any(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_any) 

se::Class* __jsb_cc_render_PipelineCapabilities_class = nullptr;
se::Object* __jsb_cc_render_PipelineCapabilities_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelineCapabilities) 

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

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

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

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

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


bool js_register_cc_render_PipelineCapabilities(se::Object* obj) {
    auto* cls = se::Class::create("PipelineCapabilities", obj, nullptr, _SE(js_new_cc_render_PipelineCapabilities)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("subpass", _SE(js_cc_render_PipelineCapabilities_subpass_get), _SE(js_cc_render_PipelineCapabilities_subpass_set)); 
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_PipelineCapabilities));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::PipelineCapabilities>(cls);
    
    __jsb_cc_render_PipelineCapabilities_proto = cls->getProto();
    __jsb_cc_render_PipelineCapabilities_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_RenderNode_class = nullptr;
se::Object* __jsb_cc_render_RenderNode_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderNode) 

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

static bool js_cc_render_RenderNode_setCustomBehavior(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderNode *arg1 = (cc::render::RenderNode *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string 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::render::RenderNode>(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)->setCustomBehavior((ccstd::string const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderNode_setCustomBehavior) 

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

static bool js_cc_render_RenderNode_name_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::RenderNode *arg1 = (cc::render::RenderNode *) NULL ;
    ccstd::string result;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderNode>(s);
    if (nullptr == arg1) return true;
    result = cc_render_RenderNode_name_get(arg1);
    
    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_PROP_GET(js_cc_render_RenderNode_name_get) 

bool js_register_cc_render_RenderNode(se::Object* obj) {
    auto* cls = se::Class::create("RenderNode", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("name", _SE(js_cc_render_RenderNode_name_get), _SE(js_cc_render_RenderNode_name_set)); 
    
    cls->defineFunction("setCustomBehavior", _SE(js_cc_render_RenderNode_setCustomBehavior)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderNode));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::RenderNode>(cls);
    
    __jsb_cc_render_RenderNode_proto = cls->getProto();
    __jsb_cc_render_RenderNode_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_Setter_class = nullptr;
se::Object* __jsb_cc_render_Setter_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_Setter) 

static bool js_cc_render_Setter_setMat4(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    ccstd::string *arg2 = 0 ;
    cc::Mat4 *arg3 = 0 ;
    ccstd::string temp2 ;
    cc::Mat4 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::render::Setter>(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;
    
    (arg1)->setMat4((ccstd::string const &)*arg2,(cc::Mat4 const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setMat4) 

static bool js_cc_render_Setter_setQuaternion(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    ccstd::string *arg2 = 0 ;
    cc::Quaternion *arg3 = 0 ;
    ccstd::string temp2 ;
    cc::Quaternion 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::render::Setter>(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;
    
    (arg1)->setQuaternion((ccstd::string const &)*arg2,(cc::Quaternion const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setQuaternion) 

static bool js_cc_render_Setter_setColor(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Color *arg3 = 0 ;
    ccstd::string temp2 ;
    gfx::Color 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::render::Setter>(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;
    
    (arg1)->setColor((ccstd::string const &)*arg2,(gfx::Color const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setColor) 

static bool js_cc_render_Setter_setVec4(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    ccstd::string *arg2 = 0 ;
    cc::Vec4 *arg3 = 0 ;
    ccstd::string temp2 ;
    cc::Vec4 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::render::Setter>(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;
    
    (arg1)->setVec4((ccstd::string const &)*arg2,(cc::Vec4 const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setVec4) 

static bool js_cc_render_Setter_setVec2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    ccstd::string *arg2 = 0 ;
    cc::Vec2 *arg3 = 0 ;
    ccstd::string temp2 ;
    cc::Vec2 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::render::Setter>(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;
    
    (arg1)->setVec2((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setVec2) 

static bool js_cc_render_Setter_setFloat(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    ccstd::string *arg2 = 0 ;
    float arg3 ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::Setter>(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"); 
    (arg1)->setFloat((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setFloat) 

static bool js_cc_render_Setter_setArrayBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    ccstd::string *arg2 = 0 ;
    ArrayBuffer *arg3 = (ArrayBuffer *) NULL ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::Setter>(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"); 
    (arg1)->setArrayBuffer((ccstd::string const &)*arg2,(ArrayBuffer const *)arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setArrayBuffer) 

static bool js_cc_render_Setter_setBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Buffer *arg3 = (gfx::Buffer *) NULL ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::Setter>(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"); 
    (arg1)->setBuffer((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setBuffer) 

static bool js_cc_render_Setter_setTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Texture *arg3 = (gfx::Texture *) NULL ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::Setter>(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"); 
    (arg1)->setTexture((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setTexture) 

static bool js_cc_render_Setter_setSampler(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Sampler *arg3 = (gfx::Sampler *) NULL ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::Setter>(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"); 
    (arg1)->setSampler((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setSampler) 

static bool js_cc_render_Setter_setBuiltinCameraConstants(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) 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::render::Setter>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->setBuiltinCameraConstants((cc::scene::Camera const *)arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setBuiltinCameraConstants) 

static bool js_cc_render_Setter_setBuiltinDirectionalLightConstants(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ;
    cc::scene::Camera *arg3 = (cc::scene::Camera *) 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::render::Setter>(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)->setBuiltinDirectionalLightConstants((cc::scene::DirectionalLight const *)arg2,(cc::scene::Camera const *)arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setBuiltinDirectionalLightConstants) 

static bool js_cc_render_Setter_setBuiltinSphereLightConstants(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    cc::scene::SphereLight *arg2 = (cc::scene::SphereLight *) NULL ;
    cc::scene::Camera *arg3 = (cc::scene::Camera *) 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::render::Setter>(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)->setBuiltinSphereLightConstants((cc::scene::SphereLight const *)arg2,(cc::scene::Camera const *)arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setBuiltinSphereLightConstants) 

static bool js_cc_render_Setter_setBuiltinSpotLightConstants(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ;
    cc::scene::Camera *arg3 = (cc::scene::Camera *) 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::render::Setter>(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)->setBuiltinSpotLightConstants((cc::scene::SpotLight const *)arg2,(cc::scene::Camera const *)arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setBuiltinSpotLightConstants) 

static bool js_cc_render_Setter_setBuiltinPointLightConstants(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    cc::scene::PointLight *arg2 = (cc::scene::PointLight *) NULL ;
    cc::scene::Camera *arg3 = (cc::scene::Camera *) 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::render::Setter>(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)->setBuiltinPointLightConstants((cc::scene::PointLight const *)arg2,(cc::scene::Camera const *)arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setBuiltinPointLightConstants) 

static bool js_cc_render_Setter_setBuiltinRangedDirectionalLightConstants(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    cc::scene::RangedDirectionalLight *arg2 = (cc::scene::RangedDirectionalLight *) NULL ;
    cc::scene::Camera *arg3 = (cc::scene::Camera *) 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::render::Setter>(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)->setBuiltinRangedDirectionalLightConstants((cc::scene::RangedDirectionalLight const *)arg2,(cc::scene::Camera const *)arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setBuiltinRangedDirectionalLightConstants) 

static bool js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
    cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ;
    uint32_t arg4 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::Setter>(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"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->setBuiltinDirectionalLightFrustumConstants((cc::scene::Camera const *)arg2,(cc::scene::DirectionalLight const *)arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_Setter_setBuiltinSpotLightFrustumConstants(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) 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::render::Setter>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->setBuiltinSpotLightFrustumConstants((cc::scene::SpotLight const *)arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Setter_setBuiltinSpotLightFrustumConstants) 

static bool js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Setter *arg1 = (cc::render::Setter *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
    cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::render::Setter>(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)->setBuiltinDirectionalLightFrustumConstants((cc::scene::Camera const *)arg2,(cc::scene::DirectionalLight const *)arg3);
    
    
    return true;
}

static bool js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 3) {
        ok = js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants) 

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

bool js_register_cc_render_Setter(se::Object* obj) {
    auto* cls = se::Class::create("Setter", obj, __jsb_cc_render_RenderNode_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("setMat4", _SE(js_cc_render_Setter_setMat4)); 
    cls->defineFunction("setQuaternion", _SE(js_cc_render_Setter_setQuaternion)); 
    cls->defineFunction("setColor", _SE(js_cc_render_Setter_setColor)); 
    cls->defineFunction("setVec4", _SE(js_cc_render_Setter_setVec4)); 
    cls->defineFunction("setVec2", _SE(js_cc_render_Setter_setVec2)); 
    cls->defineFunction("setFloat", _SE(js_cc_render_Setter_setFloat)); 
    cls->defineFunction("setArrayBuffer", _SE(js_cc_render_Setter_setArrayBuffer)); 
    cls->defineFunction("setBuffer", _SE(js_cc_render_Setter_setBuffer)); 
    cls->defineFunction("setTexture", _SE(js_cc_render_Setter_setTexture)); 
    cls->defineFunction("setSampler", _SE(js_cc_render_Setter_setSampler)); 
    cls->defineFunction("setBuiltinCameraConstants", _SE(js_cc_render_Setter_setBuiltinCameraConstants)); 
    cls->defineFunction("setBuiltinDirectionalLightConstants", _SE(js_cc_render_Setter_setBuiltinDirectionalLightConstants)); 
    cls->defineFunction("setBuiltinSphereLightConstants", _SE(js_cc_render_Setter_setBuiltinSphereLightConstants)); 
    cls->defineFunction("setBuiltinSpotLightConstants", _SE(js_cc_render_Setter_setBuiltinSpotLightConstants)); 
    cls->defineFunction("setBuiltinPointLightConstants", _SE(js_cc_render_Setter_setBuiltinPointLightConstants)); 
    cls->defineFunction("setBuiltinRangedDirectionalLightConstants", _SE(js_cc_render_Setter_setBuiltinRangedDirectionalLightConstants)); 
    cls->defineFunction("setBuiltinSpotLightFrustumConstants", _SE(js_cc_render_Setter_setBuiltinSpotLightFrustumConstants)); 
    cls->defineFunction("setBuiltinDirectionalLightFrustumConstants", _SE(js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_Setter));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::Setter>(cls);
    
    __jsb_cc_render_Setter_proto = cls->getProto();
    __jsb_cc_render_Setter_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_SceneBuilder_class = nullptr;
se::Object* __jsb_cc_render_SceneBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_SceneBuilder) 

static bool js_cc_render_SceneBuilder_useLightFrustum__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::SceneBuilder *arg1 = (cc::render::SceneBuilder *) NULL ;
    IntrusivePtr< cc::scene::Light > arg2 ;
    uint32_t arg3 ;
    cc::scene::Camera *arg4 = (cc::scene::Camera *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::render::SceneBuilder>(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");
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->useLightFrustum(arg2,arg3,(cc::scene::Camera const *)arg4);
    
    
    return true;
}

static bool js_cc_render_SceneBuilder_useLightFrustum__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::SceneBuilder *arg1 = (cc::render::SceneBuilder *) NULL ;
    IntrusivePtr< cc::scene::Light > arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::SceneBuilder>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->useLightFrustum(arg2);
    
    
    return true;
}

static bool js_cc_render_SceneBuilder_useLightFrustum__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::SceneBuilder *arg1 = (cc::render::SceneBuilder *) NULL ;
    IntrusivePtr< cc::scene::Light > arg2 ;
    uint32_t arg3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::SceneBuilder>(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)->useLightFrustum(arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_SceneBuilder_useLightFrustum(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 3) {
        ok = js_cc_render_SceneBuilder_useLightFrustum__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 1) {
        ok = js_cc_render_SceneBuilder_useLightFrustum__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_SceneBuilder_useLightFrustum__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_SceneBuilder_useLightFrustum) 

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

bool js_register_cc_render_SceneBuilder(se::Object* obj) {
    auto* cls = se::Class::create("SceneBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("useLightFrustum", _SE(js_cc_render_SceneBuilder_useLightFrustum)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_SceneBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::SceneBuilder>(cls);
    
    __jsb_cc_render_SceneBuilder_proto = cls->getProto();
    __jsb_cc_render_SceneBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_RenderQueueBuilder_class = nullptr;
se::Object* __jsb_cc_render_RenderQueueBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderQueueBuilder) 

static bool js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
    LightInfo arg3 ;
    SceneFlags arg4 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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"); 
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addSceneOfCamera(arg2,arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_RenderQueueBuilder_addScene__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
    SceneFlags arg3 ;
    cc::scene::Light *arg4 = (cc::scene::Light *) NULL ;
    cc::scene::RenderScene *arg5 = (cc::scene::RenderScene *) NULL ;
    cc::render::SceneBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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"); 
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::render::SceneBuilder *)(arg1)->addScene((cc::scene::Camera const *)arg2,arg3,arg4,arg5);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    Material *arg2 = (Material *) NULL ;
    uint32_t arg3 ;
    SceneFlags arg4 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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");
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addFullscreenQuad(arg2,arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
    Material *arg3 = (Material *) NULL ;
    uint32_t arg4 ;
    SceneFlags arg5 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addCameraQuad(arg2,arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_RenderQueueBuilder_clearRenderTarget__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Color *arg3 = 0 ;
    ccstd::string temp2 ;
    gfx::Color temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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;
    
    (arg1)->clearRenderTarget((ccstd::string const &)*arg2,(gfx::Color const &)*arg3);
    
    
    return true;
}

static bool js_cc_render_RenderQueueBuilder_setViewport(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    gfx::Viewport *arg2 = 0 ;
    gfx::Viewport 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::render::RenderQueueBuilder>(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)->setViewport((gfx::Viewport const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_setViewport) 

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

static bool js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
    LightInfo arg3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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)->addSceneOfCamera(arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_RenderQueueBuilder_addSceneOfCamera(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 3) {
        ok = js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addSceneOfCamera) 

static bool js_cc_render_RenderQueueBuilder_addScene__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
    SceneFlags arg3 ;
    cc::render::SceneBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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"); 
    
    result = (cc::render::SceneBuilder *)(arg1)->addScene((cc::scene::Camera const *)arg2,arg3);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_RenderQueueBuilder_addScene__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
    SceneFlags arg3 ;
    cc::scene::Light *arg4 = (cc::scene::Light *) NULL ;
    cc::render::SceneBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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"); 
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::render::SceneBuilder *)(arg1)->addScene((cc::scene::Camera const *)arg2,arg3,arg4);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_RenderQueueBuilder_addScene(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_RenderQueueBuilder_addScene__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_RenderQueueBuilder_addScene__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_RenderQueueBuilder_addScene__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addScene) 

static bool js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    Material *arg2 = (Material *) NULL ;
    uint32_t arg3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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)->addFullscreenQuad(arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_RenderQueueBuilder_addFullscreenQuad(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 3) {
        ok = js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addFullscreenQuad) 

static bool js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
    Material *arg3 = (Material *) NULL ;
    uint32_t arg4 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->addCameraQuad(arg2,arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_RenderQueueBuilder_addCameraQuad(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addCameraQuad) 

static bool js_cc_render_RenderQueueBuilder_clearRenderTarget__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderQueueBuilder>(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)->clearRenderTarget((ccstd::string const &)*arg2);
    
    
    return true;
}

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

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

bool js_register_cc_render_RenderQueueBuilder(se::Object* obj) {
    auto* cls = se::Class::create("RenderQueueBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("setViewport", _SE(js_cc_render_RenderQueueBuilder_setViewport)); 
    cls->defineFunction("addCustomCommand", _SE(js_cc_render_RenderQueueBuilder_addCustomCommand)); 
    cls->defineFunction("addSceneOfCamera", _SE(js_cc_render_RenderQueueBuilder_addSceneOfCamera)); 
    cls->defineFunction("addScene", _SE(js_cc_render_RenderQueueBuilder_addScene)); 
    cls->defineFunction("addFullscreenQuad", _SE(js_cc_render_RenderQueueBuilder_addFullscreenQuad)); 
    cls->defineFunction("addCameraQuad", _SE(js_cc_render_RenderQueueBuilder_addCameraQuad)); 
    cls->defineFunction("clearRenderTarget", _SE(js_cc_render_RenderQueueBuilder_clearRenderTarget)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderQueueBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::RenderQueueBuilder>(cls);
    
    __jsb_cc_render_RenderQueueBuilder_proto = cls->getProto();
    __jsb_cc_render_RenderQueueBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_BasicRenderPassBuilder_class = nullptr;
se::Object* __jsb_cc_render_BasicRenderPassBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_BasicRenderPassBuilder) 

static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::LoadOp arg3 ;
    gfx::StoreOp arg4 ;
    gfx::Color *arg5 = 0 ;
    ccstd::string temp2 ;
    gfx::Color temp5 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[3], &temp5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg5 = &temp5;
    
    (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4,(gfx::Color const &)*arg5);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::LoadOp arg3 ;
    gfx::StoreOp arg4 ;
    float arg5 ;
    uint8_t arg6 ;
    gfx::ClearFlagBit arg7 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::Sampler *arg4 = (gfx::Sampler *) NULL ;
    uint32_t arg5 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    QueueHint arg2 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp3 ;
    ccstd::string temp4 ;
    cc::render::RenderQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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 = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3,(ccstd::string const &)*arg4);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_setViewport(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    gfx::Viewport *arg2 = 0 ;
    gfx::Viewport 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::render::BasicRenderPassBuilder>(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)->setViewport((gfx::Viewport const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_setViewport) 

static bool js_cc_render_BasicRenderPassBuilder_setVersion(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint64_t arg3 ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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");
    
    (arg1)->setVersion((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_setVersion) 

static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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)->addRenderTarget((ccstd::string const &)*arg2);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::LoadOp arg3 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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"); 
    
    (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_3(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::LoadOp arg3 ;
    gfx::StoreOp arg4 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 1) {
        ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_3(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addRenderTarget) 

static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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)->addDepthStencil((ccstd::string const &)*arg2);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::LoadOp arg3 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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"); 
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_3(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::LoadOp arg3 ;
    gfx::StoreOp arg4 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_4(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::LoadOp arg3 ;
    gfx::StoreOp arg4 ;
    float arg5 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_5(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::LoadOp arg3 ;
    gfx::StoreOp arg4 ;
    float arg5 ;
    uint8_t arg6 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 6) {
        ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 1) {
        ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_3(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 4) {
        ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_4(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 5) {
        ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_5(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addDepthStencil) 

static bool js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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;
    
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::Sampler *arg4 = (gfx::Sampler *) NULL ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addTexture) 

static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    cc::render::RenderQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(s);
    if (nullptr == arg1) return true;
    result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue();
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    QueueHint arg2 ;
    cc::render::RenderQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_3(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ;
    QueueHint arg2 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp3 ;
    cc::render::RenderQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicRenderPassBuilder>(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;
    
    result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_BasicRenderPassBuilder_addQueue(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 3) {
        ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 0) {
        ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 1) {
        ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_3(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addQueue) 

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

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

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

bool js_register_cc_render_BasicRenderPassBuilder(se::Object* obj) {
    auto* cls = se::Class::create("BasicRenderPassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("showStatistics", _SE(js_cc_render_BasicRenderPassBuilder_showStatistics_get), _SE(js_cc_render_BasicRenderPassBuilder_showStatistics_set)); 
    
    cls->defineFunction("setViewport", _SE(js_cc_render_BasicRenderPassBuilder_setViewport)); 
    cls->defineFunction("setVersion", _SE(js_cc_render_BasicRenderPassBuilder_setVersion)); 
    cls->defineFunction("addRenderTarget", _SE(js_cc_render_BasicRenderPassBuilder_addRenderTarget)); 
    cls->defineFunction("addDepthStencil", _SE(js_cc_render_BasicRenderPassBuilder_addDepthStencil)); 
    cls->defineFunction("addTexture", _SE(js_cc_render_BasicRenderPassBuilder_addTexture)); 
    cls->defineFunction("addQueue", _SE(js_cc_render_BasicRenderPassBuilder_addQueue)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_BasicRenderPassBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::BasicRenderPassBuilder>(cls);
    
    __jsb_cc_render_BasicRenderPassBuilder_proto = cls->getProto();
    __jsb_cc_render_BasicRenderPassBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_BasicMultisampleRenderPassBuilder_class = nullptr;
se::Object* __jsb_cc_render_BasicMultisampleRenderPassBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_BasicMultisampleRenderPassBuilder) 

static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveRenderTarget(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string 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::render::BasicMultisampleRenderPassBuilder>(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;
    
    (arg1)->resolveRenderTarget((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicMultisampleRenderPassBuilder_resolveRenderTarget) 

static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::ResolveMode arg4 ;
    gfx::ResolveMode arg5 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicMultisampleRenderPassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicMultisampleRenderPassBuilder>(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;
    
    (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}

static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::ResolveMode arg4 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicMultisampleRenderPassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil) 

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

bool js_register_cc_render_BasicMultisampleRenderPassBuilder(se::Object* obj) {
    auto* cls = se::Class::create("BasicMultisampleRenderPassBuilder", obj, __jsb_cc_render_BasicRenderPassBuilder_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("resolveRenderTarget", _SE(js_cc_render_BasicMultisampleRenderPassBuilder_resolveRenderTarget)); 
    cls->defineFunction("resolveDepthStencil", _SE(js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_BasicMultisampleRenderPassBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::BasicMultisampleRenderPassBuilder>(cls);
    
    __jsb_cc_render_BasicMultisampleRenderPassBuilder_proto = cls->getProto();
    __jsb_cc_render_BasicMultisampleRenderPassBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_BasicPipeline_class = nullptr;
se::Object* __jsb_cc_render_BasicPipeline_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_BasicPipeline) 

static bool js_cc_render_BasicPipeline_beginSetup(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) 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::render::BasicPipeline>(s);
    if (nullptr == arg1) return true;
    (arg1)->beginSetup();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_beginSetup) 

static bool js_cc_render_BasicPipeline_endSetup(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) 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::render::BasicPipeline>(s);
    if (nullptr == arg1) return true;
    (arg1)->endSetup();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_endSetup) 

static bool js_cc_render_BasicPipeline_containsResource(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string 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::render::BasicPipeline>(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::render::BasicPipeline const *)arg1)->containsResource((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_containsResource) 

static bool js_cc_render_BasicPipeline_addRenderWindow__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    cc::scene::RenderWindow *arg6 = (cc::scene::RenderWindow *) NULL ;
    ccstd::string *arg7 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp7 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[5], &temp7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg7 = &temp7;
    
    result = (arg1)->addRenderWindow((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,(ccstd::string const &)*arg7);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_updateRenderWindow__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    cc::scene::RenderWindow *arg3 = (cc::scene::RenderWindow *) NULL ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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;
    
    (arg1)->updateRenderWindow((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_addRenderTarget__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    ResourceResidency arg6 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_addDepthStencil__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    ResourceResidency arg6 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_updateRenderTarget__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    gfx::Format arg5 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->updateRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_updateDepthStencil__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    gfx::Format arg5 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->updateDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_addBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    ResourceFlags arg4 ;
    ResourceResidency arg5 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    if(argc != 4) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (arg1)->addBuffer((ccstd::string const &)*arg2,arg3,arg4,arg5);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addBuffer) 

static bool js_cc_render_BasicPipeline_updateBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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");
    
    (arg1)->updateBuffer((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_updateBuffer) 

static bool js_cc_render_BasicPipeline_addExternalTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Texture *arg3 = (gfx::Texture *) NULL ;
    ResourceFlags arg4 ;
    ccstd::string temp2 ;
    uint32_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::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (arg1)->addExternalTexture((ccstd::string const &)*arg2,arg3,arg4);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addExternalTexture) 

static bool js_cc_render_BasicPipeline_updateExternalTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Texture *arg3 = (gfx::Texture *) NULL ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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"); 
    (arg1)->updateExternalTexture((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_updateExternalTexture) 

static bool js_cc_render_BasicPipeline_addTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::TextureType arg3 ;
    gfx::Format arg4 ;
    uint32_t arg5 ;
    uint32_t arg6 ;
    uint32_t arg7 ;
    uint32_t arg8 ;
    uint32_t arg9 ;
    gfx::SampleCount arg10 ;
    ResourceFlags arg11 ;
    ResourceResidency arg12 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    if(argc != 11) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 11);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[6], &arg8, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[7], &arg9, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[8], &arg10, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[9], &arg11, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[10], &arg12, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (arg1)->addTexture((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addTexture) 

static bool js_cc_render_BasicPipeline_updateTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    uint32_t arg6 ;
    uint32_t arg7 ;
    uint32_t arg8 ;
    gfx::SampleCount arg9 ;
    ccstd::string temp2 ;
    
    if(argc != 8) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[6], &arg8, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[7], &arg9, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->updateTexture((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_updateTexture) 

static bool js_cc_render_BasicPipeline_addResource(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    ResourceDimension arg3 ;
    gfx::Format arg4 ;
    uint32_t arg5 ;
    uint32_t arg6 ;
    uint32_t arg7 ;
    uint32_t arg8 ;
    uint32_t arg9 ;
    gfx::SampleCount arg10 ;
    ResourceFlags arg11 ;
    ResourceResidency arg12 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    if(argc != 11) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 11);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[6], &arg8, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[7], &arg9, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[8], &arg10, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[9], &arg11, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[10], &arg12, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (arg1)->addResource((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addResource) 

static bool js_cc_render_BasicPipeline_updateResource(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    uint32_t arg6 ;
    uint32_t arg7 ;
    uint32_t arg8 ;
    gfx::SampleCount arg9 ;
    ccstd::string temp2 ;
    
    if(argc != 8) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[6], &arg8, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[7], &arg9, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->updateResource((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_updateResource) 

static bool js_cc_render_BasicPipeline_beginFrame(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) 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::render::BasicPipeline>(s);
    if (nullptr == arg1) return true;
    (arg1)->beginFrame();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_beginFrame) 

static bool js_cc_render_BasicPipeline_update(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) 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::render::BasicPipeline>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->update((cc::scene::Camera const *)arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_update) 

static bool js_cc_render_BasicPipeline_endFrame(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) 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::render::BasicPipeline>(s);
    if (nullptr == arg1) return true;
    (arg1)->endFrame();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_endFrame) 

static bool js_cc_render_BasicPipeline_addRenderPass__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp4 ;
    cc::render::BasicRenderPassBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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");
    
    
    ok &= sevalue_to_native(args[2], &temp4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg4 = &temp4;
    
    result = (cc::render::BasicRenderPassBuilder *)(arg1)->addRenderPass(arg2,arg3,(ccstd::string const &)*arg4);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    ccstd::string *arg6 = 0 ;
    ccstd::string temp6 ;
    cc::render::BasicMultisampleRenderPassBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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");
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &temp6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg6 = &temp6;
    
    result = (cc::render::BasicMultisampleRenderPassBuilder *)(arg1)->addMultisampleRenderPass(arg2,arg3,arg4,arg5,(ccstd::string const &)*arg6);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_addResolvePass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::vector< ResolvePair > *arg2 = 0 ;
    ccstd::vector< ResolvePair > 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::render::BasicPipeline>(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)->addResolvePass((ccstd::vector< ResolvePair > const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addResolvePass) 

static bool js_cc_render_BasicPipeline_addCopyPass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::vector< CopyPair > *arg2 = 0 ;
    ccstd::vector< CopyPair > 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::render::BasicPipeline>(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)->addCopyPass((ccstd::vector< CopyPair > const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addCopyPass) 

static bool js_cc_render_BasicPipeline_addBuiltinReflectionProbePass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    cc::scene::Camera *arg2 = (cc::scene::Camera *) 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::render::BasicPipeline>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->addBuiltinReflectionProbePass((cc::scene::Camera const *)arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addBuiltinReflectionProbePass) 

static bool js_cc_render_BasicPipeline_getDescriptorSetLayout(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    UpdateFrequency arg3 ;
    ccstd::string temp2 ;
    gfx::DescriptorSetLayout *result = 0 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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"); 
    
    result = (gfx::DescriptorSetLayout *)(arg1)->getDescriptorSetLayout((ccstd::string const &)*arg2,arg3);
    
    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_FUNC(js_cc_render_BasicPipeline_getDescriptorSetLayout) 

static bool js_cc_render_BasicPipeline_addRenderWindow__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    cc::scene::RenderWindow *arg6 = (cc::scene::RenderWindow *) NULL ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (arg1)->addRenderWindow((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_addRenderWindow(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 6) {
        ok = js_cc_render_BasicPipeline_addRenderWindow__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 5) {
        ok = js_cc_render_BasicPipeline_addRenderWindow__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addRenderWindow) 

static bool js_cc_render_BasicPipeline_updateRenderWindow__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    cc::scene::RenderWindow *arg3 = (cc::scene::RenderWindow *) NULL ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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"); 
    (arg1)->updateRenderWindow((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_updateRenderWindow(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 3) {
        ok = js_cc_render_BasicPipeline_updateRenderWindow__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_BasicPipeline_updateRenderWindow__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_updateRenderWindow) 

static bool js_cc_render_BasicPipeline_addRenderTarget__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    result = (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_addRenderTarget(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 5) {
        ok = js_cc_render_BasicPipeline_addRenderTarget__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 4) {
        ok = js_cc_render_BasicPipeline_addRenderTarget__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addRenderTarget) 

static bool js_cc_render_BasicPipeline_addDepthStencil__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    result = (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_addDepthStencil(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 5) {
        ok = js_cc_render_BasicPipeline_addDepthStencil__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 4) {
        ok = js_cc_render_BasicPipeline_addDepthStencil__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addDepthStencil) 

static bool js_cc_render_BasicPipeline_updateRenderTarget__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->updateRenderTarget((ccstd::string const &)*arg2,arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_updateRenderTarget(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_BasicPipeline_updateRenderTarget__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_BasicPipeline_updateRenderTarget__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_updateRenderTarget) 

static bool js_cc_render_BasicPipeline_updateDepthStencil__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->updateDepthStencil((ccstd::string const &)*arg2,arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_updateDepthStencil(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_BasicPipeline_updateDepthStencil__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_BasicPipeline_updateDepthStencil__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_updateDepthStencil) 

static bool js_cc_render_BasicPipeline_addRenderPass__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    cc::render::BasicRenderPassBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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");
    
    result = (cc::render::BasicRenderPassBuilder *)(arg1)->addRenderPass(arg2,arg3);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_addRenderPass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 3) {
        ok = js_cc_render_BasicPipeline_addRenderPass__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_BasicPipeline_addRenderPass__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addRenderPass) 

static bool js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    cc::render::BasicMultisampleRenderPassBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(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");
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    result = (cc::render::BasicMultisampleRenderPassBuilder *)(arg1)->addMultisampleRenderPass(arg2,arg3,arg4,arg5);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_BasicPipeline_addMultisampleRenderPass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 5) {
        ok = js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 4) {
        ok = js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_BasicPipeline_addMultisampleRenderPass) 

static bool js_cc_render_BasicPipeline_type_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    cc::render::PipelineType result;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(s);
    if (nullptr == arg1) return true;
    result = (cc::render::PipelineType)cc_render_BasicPipeline_type_get(arg1);
    
    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_PROP_GET(js_cc_render_BasicPipeline_type_get) 

static bool js_cc_render_BasicPipeline_capabilities_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ;
    cc::render::PipelineCapabilities result;
    
    arg1 = SE_THIS_OBJECT<cc::render::BasicPipeline>(s);
    if (nullptr == arg1) return true;
    result = cc_render_BasicPipeline_capabilities_get(arg1);
    
    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_PROP_GET(js_cc_render_BasicPipeline_capabilities_get) 

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

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

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

bool js_register_cc_render_BasicPipeline(se::Object* obj) {
    auto* cls = se::Class::create("BasicPipeline", obj, __jsb_cc_render_PipelineRuntime_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("type", _SE(js_cc_render_BasicPipeline_type_get), nullptr); 
    cls->defineProperty("capabilities", _SE(js_cc_render_BasicPipeline_capabilities_get), nullptr); 
    cls->defineProperty("enableCpuLightCulling", _SE(js_cc_render_BasicPipeline_enableCpuLightCulling_get), _SE(js_cc_render_BasicPipeline_enableCpuLightCulling_set)); 
    
    cls->defineFunction("beginSetup", _SE(js_cc_render_BasicPipeline_beginSetup)); 
    cls->defineFunction("endSetup", _SE(js_cc_render_BasicPipeline_endSetup)); 
    cls->defineFunction("containsResource", _SE(js_cc_render_BasicPipeline_containsResource)); 
    cls->defineFunction("addBuffer", _SE(js_cc_render_BasicPipeline_addBuffer)); 
    cls->defineFunction("updateBuffer", _SE(js_cc_render_BasicPipeline_updateBuffer)); 
    cls->defineFunction("addExternalTexture", _SE(js_cc_render_BasicPipeline_addExternalTexture)); 
    cls->defineFunction("updateExternalTexture", _SE(js_cc_render_BasicPipeline_updateExternalTexture)); 
    cls->defineFunction("addTexture", _SE(js_cc_render_BasicPipeline_addTexture)); 
    cls->defineFunction("updateTexture", _SE(js_cc_render_BasicPipeline_updateTexture)); 
    cls->defineFunction("addResource", _SE(js_cc_render_BasicPipeline_addResource)); 
    cls->defineFunction("updateResource", _SE(js_cc_render_BasicPipeline_updateResource)); 
    cls->defineFunction("beginFrame", _SE(js_cc_render_BasicPipeline_beginFrame)); 
    cls->defineFunction("update", _SE(js_cc_render_BasicPipeline_update)); 
    cls->defineFunction("endFrame", _SE(js_cc_render_BasicPipeline_endFrame)); 
    cls->defineFunction("addResolvePass", _SE(js_cc_render_BasicPipeline_addResolvePass)); 
    cls->defineFunction("addCopyPass", _SE(js_cc_render_BasicPipeline_addCopyPass)); 
    cls->defineFunction("addBuiltinReflectionProbePass", _SE(js_cc_render_BasicPipeline_addBuiltinReflectionProbePass)); 
    cls->defineFunction("getDescriptorSetLayout", _SE(js_cc_render_BasicPipeline_getDescriptorSetLayout)); 
    cls->defineFunction("addRenderWindow", _SE(js_cc_render_BasicPipeline_addRenderWindow)); 
    cls->defineFunction("updateRenderWindow", _SE(js_cc_render_BasicPipeline_updateRenderWindow)); 
    cls->defineFunction("addRenderTarget", _SE(js_cc_render_BasicPipeline_addRenderTarget)); 
    cls->defineFunction("addDepthStencil", _SE(js_cc_render_BasicPipeline_addDepthStencil)); 
    cls->defineFunction("updateRenderTarget", _SE(js_cc_render_BasicPipeline_updateRenderTarget)); 
    cls->defineFunction("updateDepthStencil", _SE(js_cc_render_BasicPipeline_updateDepthStencil)); 
    cls->defineFunction("addRenderPass", _SE(js_cc_render_BasicPipeline_addRenderPass)); 
    cls->defineFunction("addMultisampleRenderPass", _SE(js_cc_render_BasicPipeline_addMultisampleRenderPass)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_BasicPipeline));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::BasicPipeline>(cls);
    
    __jsb_cc_render_BasicPipeline_proto = cls->getProto();
    __jsb_cc_render_BasicPipeline_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_RenderSubpassBuilder_class = nullptr;
se::Object* __jsb_cc_render_RenderSubpassBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderSubpassBuilder) 

static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    gfx::LoadOp arg5 ;
    gfx::StoreOp arg6 ;
    gfx::Color *arg7 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    gfx::Color temp7 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[5], &temp7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg7 = &temp7;
    
    (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,arg5,arg6,(gfx::Color const &)*arg7);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string *arg5 = 0 ;
    gfx::LoadOp arg6 ;
    gfx::StoreOp arg7 ;
    float arg8 ;
    uint8_t arg9 ;
    gfx::ClearFlagBit arg10 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    ccstd::string temp5 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    
    ok &= sevalue_to_native(args[3], &temp5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg5 = &temp5;
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[6], &arg8, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[7], &arg9, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[8], &arg10, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addTexture__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::Sampler *arg4 = (gfx::Sampler *) NULL ;
    uint32_t arg5 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addStorageBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addStorageBuffer) 

static bool js_cc_render_RenderSubpassBuilder_addStorageImage(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addStorageImage) 

static bool js_cc_render_RenderSubpassBuilder_setViewport(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    gfx::Viewport *arg2 = 0 ;
    gfx::Viewport 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::render::RenderSubpassBuilder>(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)->setViewport((gfx::Viewport const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_setViewport) 

static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    QueueHint arg2 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp3 ;
    ccstd::string temp4 ;
    cc::render::RenderQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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 = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3,(ccstd::string const &)*arg4);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_setCustomShaderStages(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::ShaderStageFlagBit arg3 ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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"); 
    
    (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_setCustomShaderStages) 

static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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"); 
    
    (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_3(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    gfx::LoadOp arg5 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_4(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    gfx::LoadOp arg5 ;
    gfx::StoreOp arg6 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,arg5,arg6);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addRenderTarget(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 6) {
        ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 4) {
        ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_3(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 5) {
        ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_4(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addRenderTarget) 

static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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"); 
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_3(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string *arg5 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    ccstd::string temp5 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    
    ok &= sevalue_to_native(args[3], &temp5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg5 = &temp5;
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_4(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string *arg5 = 0 ;
    gfx::LoadOp arg6 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    ccstd::string temp5 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    
    ok &= sevalue_to_native(args[3], &temp5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg5 = &temp5;
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_5(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string *arg5 = 0 ;
    gfx::LoadOp arg6 ;
    gfx::StoreOp arg7 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    ccstd::string temp5 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    
    ok &= sevalue_to_native(args[3], &temp5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg5 = &temp5;
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_6(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string *arg5 = 0 ;
    gfx::LoadOp arg6 ;
    gfx::StoreOp arg7 ;
    float arg8 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    ccstd::string temp5 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    
    ok &= sevalue_to_native(args[3], &temp5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg5 = &temp5;
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[6], &arg8, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7,arg8);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_7(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string *arg5 = 0 ;
    gfx::LoadOp arg6 ;
    gfx::StoreOp arg7 ;
    float arg8 ;
    uint8_t arg9 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    ccstd::string temp5 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    
    ok &= sevalue_to_native(args[3], &temp5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg5 = &temp5;
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[6], &arg8, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[7], &arg9, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7,arg8,arg9);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addDepthStencil(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 9) {
        ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 4) {
        ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_3(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 5) {
        ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_4(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 6) {
        ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_5(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 7) {
        ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_6(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 8) {
        ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_7(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addDepthStencil) 

static bool js_cc_render_RenderSubpassBuilder_addTexture__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addTexture__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::Sampler *arg4 = (gfx::Sampler *) NULL ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_RenderSubpassBuilder_addTexture__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_RenderSubpassBuilder_addTexture__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_RenderSubpassBuilder_addTexture__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addTexture) 

static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    cc::render::RenderQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(s);
    if (nullptr == arg1) return true;
    result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue();
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    QueueHint arg2 ;
    cc::render::RenderQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_3(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ;
    QueueHint arg2 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp3 ;
    cc::render::RenderQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderSubpassBuilder>(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;
    
    result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_RenderSubpassBuilder_addQueue(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 3) {
        ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 0) {
        ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 1) {
        ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_3(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addQueue) 

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

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

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

bool js_register_cc_render_RenderSubpassBuilder(se::Object* obj) {
    auto* cls = se::Class::create("RenderSubpassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("showStatistics", _SE(js_cc_render_RenderSubpassBuilder_showStatistics_get), _SE(js_cc_render_RenderSubpassBuilder_showStatistics_set)); 
    
    cls->defineFunction("addStorageBuffer", _SE(js_cc_render_RenderSubpassBuilder_addStorageBuffer)); 
    cls->defineFunction("addStorageImage", _SE(js_cc_render_RenderSubpassBuilder_addStorageImage)); 
    cls->defineFunction("setViewport", _SE(js_cc_render_RenderSubpassBuilder_setViewport)); 
    cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_RenderSubpassBuilder_setCustomShaderStages)); 
    cls->defineFunction("addRenderTarget", _SE(js_cc_render_RenderSubpassBuilder_addRenderTarget)); 
    cls->defineFunction("addDepthStencil", _SE(js_cc_render_RenderSubpassBuilder_addDepthStencil)); 
    cls->defineFunction("addTexture", _SE(js_cc_render_RenderSubpassBuilder_addTexture)); 
    cls->defineFunction("addQueue", _SE(js_cc_render_RenderSubpassBuilder_addQueue)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderSubpassBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::RenderSubpassBuilder>(cls);
    
    __jsb_cc_render_RenderSubpassBuilder_proto = cls->getProto();
    __jsb_cc_render_RenderSubpassBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_MultisampleRenderSubpassBuilder_class = nullptr;
se::Object* __jsb_cc_render_MultisampleRenderSubpassBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_MultisampleRenderSubpassBuilder) 

static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveRenderTarget(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string 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::render::MultisampleRenderSubpassBuilder>(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;
    
    (arg1)->resolveRenderTarget((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_MultisampleRenderSubpassBuilder_resolveRenderTarget) 

static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::ResolveMode arg4 ;
    gfx::ResolveMode arg5 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::MultisampleRenderSubpassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::MultisampleRenderSubpassBuilder>(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;
    
    (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}

static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::ResolveMode arg4 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::MultisampleRenderSubpassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil) 

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

bool js_register_cc_render_MultisampleRenderSubpassBuilder(se::Object* obj) {
    auto* cls = se::Class::create("MultisampleRenderSubpassBuilder", obj, __jsb_cc_render_RenderSubpassBuilder_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("resolveRenderTarget", _SE(js_cc_render_MultisampleRenderSubpassBuilder_resolveRenderTarget)); 
    cls->defineFunction("resolveDepthStencil", _SE(js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_MultisampleRenderSubpassBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::MultisampleRenderSubpassBuilder>(cls);
    
    __jsb_cc_render_MultisampleRenderSubpassBuilder_proto = cls->getProto();
    __jsb_cc_render_MultisampleRenderSubpassBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_ComputeQueueBuilder_class = nullptr;
se::Object* __jsb_cc_render_ComputeQueueBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_ComputeQueueBuilder) 

static bool js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputeQueueBuilder *arg1 = (cc::render::ComputeQueueBuilder *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    Material *arg5 = (Material *) NULL ;
    uint32_t arg6 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputeQueueBuilder>(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");
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->addDispatch(arg2,arg3,arg4,arg5,arg6);
    
    
    return true;
}

static bool js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputeQueueBuilder *arg1 = (cc::render::ComputeQueueBuilder *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputeQueueBuilder>(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");
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->addDispatch(arg2,arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputeQueueBuilder *arg1 = (cc::render::ComputeQueueBuilder *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    Material *arg5 = (Material *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputeQueueBuilder>(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");
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->addDispatch(arg2,arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_ComputeQueueBuilder_addDispatch(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 5) {
        ok = js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 4) {
        ok = js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_ComputeQueueBuilder_addDispatch) 

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

bool js_register_cc_render_ComputeQueueBuilder(se::Object* obj) {
    auto* cls = se::Class::create("ComputeQueueBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("addDispatch", _SE(js_cc_render_ComputeQueueBuilder_addDispatch)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_ComputeQueueBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::ComputeQueueBuilder>(cls);
    
    __jsb_cc_render_ComputeQueueBuilder_proto = cls->getProto();
    __jsb_cc_render_ComputeQueueBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_ComputeSubpassBuilder_class = nullptr;
se::Object* __jsb_cc_render_ComputeSubpassBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_ComputeSubpassBuilder) 

static bool js_cc_render_ComputeSubpassBuilder_addRenderTarget(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string 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::render::ComputeSubpassBuilder>(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;
    
    (arg1)->addRenderTarget((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addRenderTarget) 

static bool js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::Sampler *arg4 = (gfx::Sampler *) NULL ;
    uint32_t arg5 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputeSubpassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_ComputeSubpassBuilder_addStorageBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::ComputeSubpassBuilder>(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;
    
    (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addStorageBuffer) 

static bool js_cc_render_ComputeSubpassBuilder_addStorageImage(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::ComputeSubpassBuilder>(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;
    
    (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addStorageImage) 

static bool js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    cc::render::ComputeQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputeSubpassBuilder>(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;
    
    result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_ComputeSubpassBuilder_setCustomShaderStages(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::ShaderStageFlagBit arg3 ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::ComputeSubpassBuilder>(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"); 
    
    (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_setCustomShaderStages) 

static bool js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputeSubpassBuilder>(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;
    
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}

static bool js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::Sampler *arg4 = (gfx::Sampler *) NULL ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputeSubpassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_ComputeSubpassBuilder_addTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addTexture) 

static bool js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ;
    cc::render::ComputeQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputeSubpassBuilder>(s);
    if (nullptr == arg1) return true;
    result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue();
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    cc::render::ComputeQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputeSubpassBuilder>(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 = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

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

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

bool js_register_cc_render_ComputeSubpassBuilder(se::Object* obj) {
    auto* cls = se::Class::create("ComputeSubpassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("addRenderTarget", _SE(js_cc_render_ComputeSubpassBuilder_addRenderTarget)); 
    cls->defineFunction("addStorageBuffer", _SE(js_cc_render_ComputeSubpassBuilder_addStorageBuffer)); 
    cls->defineFunction("addStorageImage", _SE(js_cc_render_ComputeSubpassBuilder_addStorageImage)); 
    cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_ComputeSubpassBuilder_setCustomShaderStages)); 
    cls->defineFunction("addTexture", _SE(js_cc_render_ComputeSubpassBuilder_addTexture)); 
    cls->defineFunction("addQueue", _SE(js_cc_render_ComputeSubpassBuilder_addQueue)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_ComputeSubpassBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::ComputeSubpassBuilder>(cls);
    
    __jsb_cc_render_ComputeSubpassBuilder_proto = cls->getProto();
    __jsb_cc_render_ComputeSubpassBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_RenderPassBuilder_class = nullptr;
se::Object* __jsb_cc_render_RenderPassBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderPassBuilder) 

static bool js_cc_render_RenderPassBuilder_addStorageBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::RenderPassBuilder>(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;
    
    (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addStorageBuffer) 

static bool js_cc_render_RenderPassBuilder_addStorageImage(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::RenderPassBuilder>(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;
    
    (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addStorageImage) 

static bool js_cc_render_RenderPassBuilder_addMaterialTexture__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::ShaderStageFlagBit arg3 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderPassBuilder>(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"); 
    
    (arg1)->addMaterialTexture((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_RenderPassBuilder_addRenderSubpass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    cc::render::RenderSubpassBuilder *result = 0 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::RenderPassBuilder>(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 = (cc::render::RenderSubpassBuilder *)(arg1)->addRenderSubpass((ccstd::string const &)*arg2);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addRenderSubpass) 

static bool js_cc_render_RenderPassBuilder_addMultisampleRenderSubpass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp4 ;
    cc::render::MultisampleRenderSubpassBuilder *result = 0 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::RenderPassBuilder>(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");
    
    
    ok &= sevalue_to_native(args[2], &temp4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg4 = &temp4;
    
    result = (cc::render::MultisampleRenderSubpassBuilder *)(arg1)->addMultisampleRenderSubpass(arg2,arg3,(ccstd::string const &)*arg4);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addMultisampleRenderSubpass) 

static bool js_cc_render_RenderPassBuilder_addComputeSubpass__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    cc::render::ComputeSubpassBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderPassBuilder>(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 = (cc::render::ComputeSubpassBuilder *)(arg1)->addComputeSubpass((ccstd::string const &)*arg2);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_RenderPassBuilder_setCustomShaderStages(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::ShaderStageFlagBit arg3 ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::RenderPassBuilder>(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"); 
    
    (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderPassBuilder_setCustomShaderStages) 

static bool js_cc_render_RenderPassBuilder_addMaterialTexture__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderPassBuilder>(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)->addMaterialTexture((ccstd::string const &)*arg2);
    
    
    return true;
}

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

static bool js_cc_render_RenderPassBuilder_addComputeSubpass__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ;
    cc::render::ComputeSubpassBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::RenderPassBuilder>(s);
    if (nullptr == arg1) return true;
    result = (cc::render::ComputeSubpassBuilder *)(arg1)->addComputeSubpass();
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

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

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

bool js_register_cc_render_RenderPassBuilder(se::Object* obj) {
    auto* cls = se::Class::create("RenderPassBuilder", obj, __jsb_cc_render_BasicRenderPassBuilder_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("addStorageBuffer", _SE(js_cc_render_RenderPassBuilder_addStorageBuffer)); 
    cls->defineFunction("addStorageImage", _SE(js_cc_render_RenderPassBuilder_addStorageImage)); 
    cls->defineFunction("addRenderSubpass", _SE(js_cc_render_RenderPassBuilder_addRenderSubpass)); 
    cls->defineFunction("addMultisampleRenderSubpass", _SE(js_cc_render_RenderPassBuilder_addMultisampleRenderSubpass)); 
    cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_RenderPassBuilder_setCustomShaderStages)); 
    cls->defineFunction("addMaterialTexture", _SE(js_cc_render_RenderPassBuilder_addMaterialTexture)); 
    cls->defineFunction("addComputeSubpass", _SE(js_cc_render_RenderPassBuilder_addComputeSubpass)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderPassBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::RenderPassBuilder>(cls);
    
    __jsb_cc_render_RenderPassBuilder_proto = cls->getProto();
    __jsb_cc_render_RenderPassBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_MultisampleRenderPassBuilder_class = nullptr;
se::Object* __jsb_cc_render_MultisampleRenderPassBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_MultisampleRenderPassBuilder) 

static bool js_cc_render_MultisampleRenderPassBuilder_addStorageBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::MultisampleRenderPassBuilder *arg1 = (cc::render::MultisampleRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::MultisampleRenderPassBuilder>(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;
    
    (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_MultisampleRenderPassBuilder_addStorageBuffer) 

static bool js_cc_render_MultisampleRenderPassBuilder_addStorageImage(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::MultisampleRenderPassBuilder *arg1 = (cc::render::MultisampleRenderPassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::MultisampleRenderPassBuilder>(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;
    
    (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_MultisampleRenderPassBuilder_addStorageImage) 

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

bool js_register_cc_render_MultisampleRenderPassBuilder(se::Object* obj) {
    auto* cls = se::Class::create("MultisampleRenderPassBuilder", obj, __jsb_cc_render_BasicMultisampleRenderPassBuilder_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("addStorageBuffer", _SE(js_cc_render_MultisampleRenderPassBuilder_addStorageBuffer)); 
    cls->defineFunction("addStorageImage", _SE(js_cc_render_MultisampleRenderPassBuilder_addStorageImage)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_MultisampleRenderPassBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::MultisampleRenderPassBuilder>(cls);
    
    __jsb_cc_render_MultisampleRenderPassBuilder_proto = cls->getProto();
    __jsb_cc_render_MultisampleRenderPassBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_ComputePassBuilder_class = nullptr;
se::Object* __jsb_cc_render_ComputePassBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_ComputePassBuilder) 

static bool js_cc_render_ComputePassBuilder_addTexture__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::Sampler *arg4 = (gfx::Sampler *) NULL ;
    uint32_t arg5 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_ComputePassBuilder_addStorageBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(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;
    
    (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addStorageBuffer) 

static bool js_cc_render_ComputePassBuilder_addStorageImage(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    AccessType arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp4 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(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;
    
    (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addStorageImage) 

static bool js_cc_render_ComputePassBuilder_addMaterialTexture__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::ShaderStageFlagBit arg3 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(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"); 
    
    (arg1)->addMaterialTexture((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_ComputePassBuilder_addQueue__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    cc::render::ComputeQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(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;
    
    result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_ComputePassBuilder_setCustomShaderStages(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::ShaderStageFlagBit arg3 ;
    ccstd::string temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(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"); 
    
    (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_ComputePassBuilder_setCustomShaderStages) 

static bool js_cc_render_ComputePassBuilder_addTexture__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(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;
    
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}

static bool js_cc_render_ComputePassBuilder_addTexture__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    gfx::Sampler *arg4 = (gfx::Sampler *) NULL ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_ComputePassBuilder_addTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_ComputePassBuilder_addTexture__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_ComputePassBuilder_addTexture__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_ComputePassBuilder_addTexture__SWIG_2(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addTexture) 

static bool js_cc_render_ComputePassBuilder_addMaterialTexture__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(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)->addMaterialTexture((ccstd::string const &)*arg2);
    
    
    return true;
}

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

static bool js_cc_render_ComputePassBuilder_addQueue__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    cc::render::ComputeQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(s);
    if (nullptr == arg1) return true;
    result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue();
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

static bool js_cc_render_ComputePassBuilder_addQueue__SWIG_2(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    cc::render::ComputeQueueBuilder *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::ComputePassBuilder>(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 = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}

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

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

bool js_register_cc_render_ComputePassBuilder(se::Object* obj) {
    auto* cls = se::Class::create("ComputePassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("addStorageBuffer", _SE(js_cc_render_ComputePassBuilder_addStorageBuffer)); 
    cls->defineFunction("addStorageImage", _SE(js_cc_render_ComputePassBuilder_addStorageImage)); 
    cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_ComputePassBuilder_setCustomShaderStages)); 
    cls->defineFunction("addTexture", _SE(js_cc_render_ComputePassBuilder_addTexture)); 
    cls->defineFunction("addMaterialTexture", _SE(js_cc_render_ComputePassBuilder_addMaterialTexture)); 
    cls->defineFunction("addQueue", _SE(js_cc_render_ComputePassBuilder_addQueue)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_ComputePassBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::ComputePassBuilder>(cls);
    
    __jsb_cc_render_ComputePassBuilder_proto = cls->getProto();
    __jsb_cc_render_ComputePassBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_Pipeline_class = nullptr;
se::Object* __jsb_cc_render_Pipeline_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_Pipeline) 

static bool js_cc_render_Pipeline_addStorageBuffer__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    ResourceResidency arg5 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,arg4,arg5);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_Pipeline_addStorageTexture__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    ResourceResidency arg6 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (arg1)->addStorageTexture((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_Pipeline_addShadingRateTexture__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    ResourceResidency arg5 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (arg1)->addShadingRateTexture((ccstd::string const &)*arg2,arg3,arg4,arg5);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_Pipeline_updateStorageBuffer__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    gfx::Format arg4 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->updateStorageBuffer((ccstd::string const &)*arg2,arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_Pipeline_updateStorageTexture__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    gfx::Format arg5 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    (arg1)->updateStorageTexture((ccstd::string const &)*arg2,arg3,arg4,arg5);
    
    
    return true;
}

static bool js_cc_render_Pipeline_updateShadingRateTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    ccstd::string temp2 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->updateShadingRateTexture((ccstd::string const &)*arg2,arg3,arg4);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Pipeline_updateShadingRateTexture) 

static bool js_cc_render_Pipeline_addRenderPass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp4 ;
    cc::render::RenderPassBuilder *result = 0 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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");
    
    
    ok &= sevalue_to_native(args[2], &temp4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg4 = &temp4;
    
    result = (cc::render::RenderPassBuilder *)(arg1)->addRenderPass(arg2,arg3,(ccstd::string const &)*arg4);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Pipeline_addRenderPass) 

static bool js_cc_render_Pipeline_addMultisampleRenderPass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    ccstd::string *arg6 = 0 ;
    ccstd::string temp6 ;
    cc::render::MultisampleRenderPassBuilder *result = 0 ;
    
    if(argc != 5) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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");
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &temp6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg6 = &temp6;
    
    result = (cc::render::MultisampleRenderPassBuilder *)(arg1)->addMultisampleRenderPass(arg2,arg3,arg4,arg5,(ccstd::string const &)*arg6);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Pipeline_addMultisampleRenderPass) 

static bool js_cc_render_Pipeline_addComputePass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    cc::render::ComputePassBuilder *result = 0 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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 = (cc::render::ComputePassBuilder *)(arg1)->addComputePass((ccstd::string const &)*arg2);
    
    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()); 
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Pipeline_addComputePass) 

static bool js_cc_render_Pipeline_addUploadPass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::vector< UploadPair > *arg2 = 0 ;
    ccstd::vector< UploadPair > 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::render::Pipeline>(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)->addUploadPass(*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Pipeline_addUploadPass) 

static bool js_cc_render_Pipeline_addMovePass(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::vector< MovePair > *arg2 = 0 ;
    ccstd::vector< MovePair > 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::render::Pipeline>(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)->addMovePass((ccstd::vector< MovePair > const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Pipeline_addMovePass) 

static bool js_cc_render_Pipeline_addCustomBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::BufferInfo *arg3 = 0 ;
    std::string *arg4 = 0 ;
    ccstd::string temp2 ;
    gfx::BufferInfo temp3 ;
    std::string temp4 ;
    uint32_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::render::Pipeline>(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;
    
    result = (arg1)->addCustomBuffer((ccstd::string const &)*arg2,(gfx::BufferInfo const &)*arg3,(std::string const &)*arg4);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Pipeline_addCustomBuffer) 

static bool js_cc_render_Pipeline_addCustomTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::TextureInfo *arg3 = 0 ;
    std::string *arg4 = 0 ;
    ccstd::string temp2 ;
    gfx::TextureInfo temp3 ;
    std::string temp4 ;
    uint32_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::render::Pipeline>(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;
    
    result = (arg1)->addCustomTexture((ccstd::string const &)*arg2,(gfx::TextureInfo const &)*arg3,(std::string const &)*arg4);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Pipeline_addCustomTexture) 

static bool js_cc_render_Pipeline_addStorageBuffer__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    result = (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,arg4);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_Pipeline_addStorageBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_Pipeline_addStorageBuffer__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_Pipeline_addStorageBuffer__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_Pipeline_addStorageBuffer) 

static bool js_cc_render_Pipeline_addStorageTexture__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    gfx::Format arg3 ;
    uint32_t arg4 ;
    uint32_t arg5 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    result = (arg1)->addStorageTexture((ccstd::string const &)*arg2,arg3,arg4,arg5);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_Pipeline_addStorageTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 5) {
        ok = js_cc_render_Pipeline_addStorageTexture__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 4) {
        ok = js_cc_render_Pipeline_addStorageTexture__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_Pipeline_addStorageTexture) 

static bool js_cc_render_Pipeline_addShadingRateTexture__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    ccstd::string temp2 ;
    uint32_t result;
    
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    result = (arg1)->addShadingRateTexture((ccstd::string const &)*arg2,arg3,arg4);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}

static bool js_cc_render_Pipeline_addShadingRateTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_Pipeline_addShadingRateTexture__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_Pipeline_addShadingRateTexture__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_Pipeline_addShadingRateTexture) 

static bool js_cc_render_Pipeline_updateStorageBuffer__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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");
    
    (arg1)->updateStorageBuffer((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}

static bool js_cc_render_Pipeline_updateStorageBuffer(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 3) {
        ok = js_cc_render_Pipeline_updateStorageBuffer__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_render_Pipeline_updateStorageBuffer__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_Pipeline_updateStorageBuffer) 

static bool js_cc_render_Pipeline_updateStorageTexture__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
    ccstd::string *arg2 = 0 ;
    uint32_t arg3 ;
    uint32_t arg4 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::render::Pipeline>(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], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->updateStorageTexture((ccstd::string const &)*arg2,arg3,arg4);
    
    
    return true;
}

static bool js_cc_render_Pipeline_updateStorageTexture(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 4) {
        ok = js_cc_render_Pipeline_updateStorageTexture__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_render_Pipeline_updateStorageTexture__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_render_Pipeline_updateStorageTexture) 

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

bool js_register_cc_render_Pipeline(se::Object* obj) {
    auto* cls = se::Class::create("Pipeline", obj, __jsb_cc_render_BasicPipeline_proto, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("updateShadingRateTexture", _SE(js_cc_render_Pipeline_updateShadingRateTexture)); 
    cls->defineFunction("addRenderPass", _SE(js_cc_render_Pipeline_addRenderPass)); 
    cls->defineFunction("addMultisampleRenderPass", _SE(js_cc_render_Pipeline_addMultisampleRenderPass)); 
    cls->defineFunction("addComputePass", _SE(js_cc_render_Pipeline_addComputePass)); 
    cls->defineFunction("addUploadPass", _SE(js_cc_render_Pipeline_addUploadPass)); 
    cls->defineFunction("addMovePass", _SE(js_cc_render_Pipeline_addMovePass)); 
    cls->defineFunction("addCustomBuffer", _SE(js_cc_render_Pipeline_addCustomBuffer)); 
    cls->defineFunction("addCustomTexture", _SE(js_cc_render_Pipeline_addCustomTexture)); 
    cls->defineFunction("addStorageBuffer", _SE(js_cc_render_Pipeline_addStorageBuffer)); 
    cls->defineFunction("addStorageTexture", _SE(js_cc_render_Pipeline_addStorageTexture)); 
    cls->defineFunction("addShadingRateTexture", _SE(js_cc_render_Pipeline_addShadingRateTexture)); 
    cls->defineFunction("updateStorageBuffer", _SE(js_cc_render_Pipeline_updateStorageBuffer)); 
    cls->defineFunction("updateStorageTexture", _SE(js_cc_render_Pipeline_updateStorageTexture)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_Pipeline));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::Pipeline>(cls);
    
    __jsb_cc_render_Pipeline_proto = cls->getProto();
    __jsb_cc_render_Pipeline_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_PipelinePassBuilder_class = nullptr;
se::Object* __jsb_cc_render_PipelinePassBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelinePassBuilder) 

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

static bool js_cc_render_PipelinePassBuilder_getConfigOrder(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelinePassBuilder *arg1 = (cc::render::PipelinePassBuilder *) NULL ;
    uint32_t 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::render::PipelinePassBuilder>(s);
    if (nullptr == arg1) return true;
    result = ((cc::render::PipelinePassBuilder const *)arg1)->getConfigOrder();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelinePassBuilder_getConfigOrder) 

static bool js_cc_render_PipelinePassBuilder_getRenderOrder(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelinePassBuilder *arg1 = (cc::render::PipelinePassBuilder *) NULL ;
    uint32_t 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::render::PipelinePassBuilder>(s);
    if (nullptr == arg1) return true;
    result = ((cc::render::PipelinePassBuilder const *)arg1)->getRenderOrder();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelinePassBuilder_getRenderOrder) 

bool js_register_cc_render_PipelinePassBuilder(se::Object* obj) {
    auto* cls = se::Class::create("PipelinePassBuilder", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("getConfigOrder", _SE(js_cc_render_PipelinePassBuilder_getConfigOrder)); 
    cls->defineFunction("getRenderOrder", _SE(js_cc_render_PipelinePassBuilder_getRenderOrder)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_PipelinePassBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::PipelinePassBuilder>(cls);
    
    __jsb_cc_render_PipelinePassBuilder_proto = cls->getProto();
    __jsb_cc_render_PipelinePassBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_PipelineBuilder_class = nullptr;
se::Object* __jsb_cc_render_PipelineBuilder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelineBuilder) 

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

static bool js_cc_render_PipelineBuilder_windowResize(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineBuilder *arg1 = (cc::render::PipelineBuilder *) NULL ;
    cc::render::BasicPipeline *arg2 = (cc::render::BasicPipeline *) NULL ;
    cc::scene::RenderWindow *arg3 = (cc::scene::RenderWindow *) NULL ;
    cc::scene::Camera *arg4 = (cc::scene::Camera *) NULL ;
    uint32_t arg5 ;
    uint32_t arg6 ;
    
    if(argc != 5) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::PipelineBuilder>(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"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->windowResize(arg2,arg3,arg4,arg5,arg6);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineBuilder_windowResize) 

static bool js_cc_render_PipelineBuilder_setup(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineBuilder *arg1 = (cc::render::PipelineBuilder *) NULL ;
    ccstd::vector< cc::scene::Camera * > *arg2 = 0 ;
    cc::render::BasicPipeline *arg3 = (cc::render::BasicPipeline *) NULL ;
    ccstd::vector< cc::scene::Camera * > temp2 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::PipelineBuilder>(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"); 
    (arg1)->setup((ccstd::vector< cc::scene::Camera * > const &)*arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineBuilder_setup) 

static bool js_cc_render_PipelineBuilder_onGlobalPipelineStateChanged(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::PipelineBuilder *arg1 = (cc::render::PipelineBuilder *) 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::render::PipelineBuilder>(s);
    if (nullptr == arg1) return true;
    (arg1)->onGlobalPipelineStateChanged();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_PipelineBuilder_onGlobalPipelineStateChanged) 

bool js_register_cc_render_PipelineBuilder(se::Object* obj) {
    auto* cls = se::Class::create("PipelineBuilder", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("windowResize", _SE(js_cc_render_PipelineBuilder_windowResize)); 
    cls->defineFunction("setup", _SE(js_cc_render_PipelineBuilder_setup)); 
    cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_render_PipelineBuilder_onGlobalPipelineStateChanged)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_PipelineBuilder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::PipelineBuilder>(cls);
    
    __jsb_cc_render_PipelineBuilder_proto = cls->getProto();
    __jsb_cc_render_PipelineBuilder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_RenderingModule_class = nullptr;
se::Object* __jsb_cc_render_RenderingModule_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderingModule) 

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

static bool js_cc_render_RenderingModule_getPassID(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderingModule *arg1 = (cc::render::RenderingModule *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    uint32_t 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::render::RenderingModule>(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 = ((cc::render::RenderingModule const *)arg1)->getPassID((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderingModule_getPassID) 

static bool js_cc_render_RenderingModule_getSubpassID(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderingModule *arg1 = (cc::render::RenderingModule *) NULL ;
    uint32_t arg2 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp3 ;
    uint32_t result;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::RenderingModule>(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;
    
    result = ((cc::render::RenderingModule const *)arg1)->getSubpassID(arg2,(ccstd::string const &)*arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderingModule_getSubpassID) 

static bool js_cc_render_RenderingModule_getPhaseID(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderingModule *arg1 = (cc::render::RenderingModule *) NULL ;
    uint32_t arg2 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp3 ;
    uint32_t result;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::render::RenderingModule>(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;
    
    result = ((cc::render::RenderingModule const *)arg1)->getPhaseID(arg2,(ccstd::string const &)*arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_RenderingModule_getPhaseID) 

bool js_register_cc_render_RenderingModule(se::Object* obj) {
    auto* cls = se::Class::create("RenderingModule", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("getPassID", _SE(js_cc_render_RenderingModule_getPassID)); 
    cls->defineFunction("getSubpassID", _SE(js_cc_render_RenderingModule_getSubpassID)); 
    cls->defineFunction("getPhaseID", _SE(js_cc_render_RenderingModule_getPhaseID)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderingModule));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::RenderingModule>(cls);
    
    __jsb_cc_render_RenderingModule_proto = cls->getProto();
    __jsb_cc_render_RenderingModule_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_render_Factory_class = nullptr;
se::Object* __jsb_cc_render_Factory_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_Factory) 

static bool js_cc_render_Factory_init_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    gfx::Device *arg1 = (gfx::Device *) NULL ;
    ccstd::vector< unsigned char > *arg2 = 0 ;
    ccstd::vector< unsigned char > temp2 ;
    cc::render::RenderingModule *result = 0 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (cc::render::RenderingModule *)cc::render::Factory::init(arg1,(ccstd::vector< unsigned char > const &)*arg2);
    
    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_FUNC(js_cc_render_Factory_init_static) 

static bool js_cc_render_Factory_destroy_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::RenderingModule *arg1 = (cc::render::RenderingModule *) NULL ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc::render::Factory::destroy(arg1);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_render_Factory_destroy_static) 

static bool js_cc_render_Factory_createPipeline_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::render::Pipeline *result = 0 ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = (cc::render::Pipeline *)cc::render::Factory::createPipeline();
    
    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_FUNC(js_cc_render_Factory_createPipeline_static) 

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

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

bool js_register_cc_render_Factory(se::Object* obj) {
    auto* cls = se::Class::create("Factory", obj, nullptr, _SE(js_new_cc_render_Factory)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    
    
    cls->defineStaticFunction("init", _SE(js_cc_render_Factory_init_static)); 
    cls->defineStaticFunction("destroy", _SE(js_cc_render_Factory_destroy_static)); 
    cls->defineStaticFunction("createPipeline", _SE(js_cc_render_Factory_createPipeline_static)); 
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_render_Factory));
    
    
    cls->install();
    JSBClassType::registerClass<cc::render::Factory>(cls);
    
    __jsb_cc_render_Factory_proto = cls->getProto();
    __jsb_cc_render_Factory_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}




bool register_all_render(se::Object* obj) {
    // Get the ns
    se::Value nsVal;
    if (!obj->getProperty("render", &nsVal, true))
    {
        se::HandleObject jsobj(se::Object::createPlainObject());
        nsVal.setObject(jsobj);
        obj->setProperty("render", nsVal);
    }
    se::Object* ns = nsVal.toObject();
    /* Register classes */
    js_register_cc_render_PipelineRuntime(ns); 
    js_register_cc_render_PipelineCapabilities(ns); 
    js_register_cc_render_RenderNode(ns); 
    js_register_cc_render_Setter(ns); 
    js_register_cc_render_SceneBuilder(ns); 
    js_register_cc_render_RenderQueueBuilder(ns); 
    js_register_cc_render_BasicRenderPassBuilder(ns); 
    js_register_cc_render_BasicMultisampleRenderPassBuilder(ns); 
    js_register_cc_render_BasicPipeline(ns); 
    js_register_cc_render_RenderSubpassBuilder(ns); 
    js_register_cc_render_MultisampleRenderSubpassBuilder(ns); 
    js_register_cc_render_ComputeQueueBuilder(ns); 
    js_register_cc_render_ComputeSubpassBuilder(ns); 
    js_register_cc_render_RenderPassBuilder(ns); 
    js_register_cc_render_MultisampleRenderPassBuilder(ns); 
    js_register_cc_render_ComputePassBuilder(ns); 
    js_register_cc_render_Pipeline(ns); 
    js_register_cc_render_PipelinePassBuilder(ns); 
    js_register_cc_render_PipelineBuilder(ns); 
    js_register_cc_render_RenderingModule(ns); 
    js_register_cc_render_Factory(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
