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

2485 lines
95 KiB
C++

#include "cocos/bindings/auto/jsb_pipeline_auto.h"
#include "cocos/bindings/manual/jsb_conversions.h"
#include "cocos/bindings/manual/jsb_global.h"
#include "renderer/pipeline/forward/ForwardPipeline.h"
#include "renderer/pipeline/forward/ForwardFlow.h"
#include "renderer/pipeline/forward/ForwardStage.h"
#include "renderer/pipeline/shadow/ShadowFlow.h"
#include "renderer/pipeline/shadow/ShadowStage.h"
#include "renderer/pipeline/ui/UIFlow.h"
#include "renderer/pipeline/ui/UIStage.h"
#include "renderer/pipeline/RenderPipeline.h"
#include "renderer/pipeline/RenderFlow.h"
#include "renderer/pipeline/RenderStage.h"
#include "renderer/pipeline/Define.h"
#include "renderer/pipeline/RenderView.h"
#include "renderer/pipeline/helper/SharedMemory.h"
#include "renderer/pipeline/InstancedBuffer.h"
#include "cocos/renderer/core/Core.h"
#include "cocos/renderer/core/gfx/GFXDescriptorSet.h"
#ifndef JSB_ALLOC
#define JSB_ALLOC(kls, ...) new (std::nothrow) kls(__VA_ARGS__)
#endif
#ifndef JSB_FREE
#define JSB_FREE(ptr) delete ptr
#endif
se::Object* __jsb_cc_pipeline_RenderQueueDesc_proto = nullptr;
se::Class* __jsb_cc_pipeline_RenderQueueDesc_class = nullptr;
static bool js_pipeline_RenderQueueDesc_get_isTransparent(se::State& s)
{
cc::pipeline::RenderQueueDesc* cobj = (cc::pipeline::RenderQueueDesc*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderQueueDesc_get_isTransparent : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= boolean_to_seval(cobj->isTransparent, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderQueueDesc_get_isTransparent)
static bool js_pipeline_RenderQueueDesc_set_isTransparent(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderQueueDesc* cobj = (cc::pipeline::RenderQueueDesc*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderQueueDesc_set_isTransparent : Invalid Native Object");
CC_UNUSED bool ok = true;
bool arg0;
ok &= seval_to_boolean(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderQueueDesc_set_isTransparent : Error processing new value");
cobj->isTransparent = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderQueueDesc_set_isTransparent)
static bool js_pipeline_RenderQueueDesc_get_sortMode(se::State& s)
{
cc::pipeline::RenderQueueDesc* cobj = (cc::pipeline::RenderQueueDesc*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderQueueDesc_get_sortMode : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= int32_to_seval((int)cobj->sortMode, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderQueueDesc_get_sortMode)
static bool js_pipeline_RenderQueueDesc_set_sortMode(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderQueueDesc* cobj = (cc::pipeline::RenderQueueDesc*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderQueueDesc_set_sortMode : Invalid Native Object");
CC_UNUSED bool ok = true;
cc::pipeline::RenderQueueSortMode arg0;
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cc::pipeline::RenderQueueSortMode)tmp; } while(false);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderQueueDesc_set_sortMode : Error processing new value");
cobj->sortMode = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderQueueDesc_set_sortMode)
static bool js_pipeline_RenderQueueDesc_get_stages(se::State& s)
{
cc::pipeline::RenderQueueDesc* cobj = (cc::pipeline::RenderQueueDesc*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderQueueDesc_get_stages : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= std_vector_string_to_seval(cobj->stages, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderQueueDesc_get_stages)
static bool js_pipeline_RenderQueueDesc_set_stages(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderQueueDesc* cobj = (cc::pipeline::RenderQueueDesc*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderQueueDesc_set_stages : Invalid Native Object");
CC_UNUSED bool ok = true;
std::vector<std::string> arg0;
ok &= seval_to_std_vector_string(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderQueueDesc_set_stages : Error processing new value");
cobj->stages = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderQueueDesc_set_stages)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_RenderQueueDesc_finalize)
static bool js_pipeline_RenderQueueDesc_constructor(se::State& s)
{
CC_UNUSED bool ok = true;
const auto& args = s.args();
size_t argc = args.size();
if(argc == 0)
{
cc::pipeline::RenderQueueDesc* cobj = JSB_ALLOC(cc::pipeline::RenderQueueDesc);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
else if(argc == 1 && args[0].isObject())
{
se::Object *json = args[0].toObject();
se::Value field;
cc::pipeline::RenderQueueDesc* cobj = JSB_ALLOC(cc::pipeline::RenderQueueDesc);
bool arg0;
json->getProperty("isTransparent", &field);
if(!field.isUndefined()) {
ok &= seval_to_boolean(field, &arg0);
cobj->isTransparent = arg0;
}
cc::pipeline::RenderQueueSortMode arg1;
json->getProperty("sortMode", &field);
if(!field.isUndefined()) {
do { int32_t tmp = 0; ok &= seval_to_int32(field, &tmp); arg1 = (cc::pipeline::RenderQueueSortMode)tmp; } while(false);
cobj->sortMode = arg1;
}
std::vector<std::string> arg2;
json->getProperty("stages", &field);
if(!field.isUndefined()) {
ok &= seval_to_std_vector_string(field, &arg2);
cobj->stages = arg2;
}
if(!ok) {
JSB_FREE(cobj);
SE_REPORT_ERROR("argument convertion error");
return false;
}
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
else
{
cc::pipeline::RenderQueueDesc* cobj = JSB_ALLOC(cc::pipeline::RenderQueueDesc);
if (argc > 0 && !args[0].isUndefined()) {
bool arg0;
ok &= seval_to_boolean(args[0], &arg0);
cobj->isTransparent = arg0;
}
if (argc > 1 && !args[1].isUndefined()) {
cc::pipeline::RenderQueueSortMode arg1;
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (cc::pipeline::RenderQueueSortMode)tmp; } while(false);
cobj->sortMode = arg1;
}
if (argc > 2 && !args[2].isUndefined()) {
std::vector<std::string> arg2;
ok &= seval_to_std_vector_string(args[2], &arg2);
cobj->stages = arg2;
}
if(!ok) {
JSB_FREE(cobj);
SE_REPORT_ERROR("Argument convertion error");
return false;
}
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
return false;
}
SE_BIND_CTOR(js_pipeline_RenderQueueDesc_constructor, __jsb_cc_pipeline_RenderQueueDesc_class, js_cc_pipeline_RenderQueueDesc_finalize)
static bool js_cc_pipeline_RenderQueueDesc_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::RenderQueueDesc* cobj = (cc::pipeline::RenderQueueDesc*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_RenderQueueDesc_finalize)
bool js_register_pipeline_RenderQueueDesc(se::Object* obj)
{
auto cls = se::Class::create("RenderQueueDesc", obj, nullptr, _SE(js_pipeline_RenderQueueDesc_constructor));
cls->defineProperty("isTransparent", _SE(js_pipeline_RenderQueueDesc_get_isTransparent), _SE(js_pipeline_RenderQueueDesc_set_isTransparent));
cls->defineProperty("sortMode", _SE(js_pipeline_RenderQueueDesc_get_sortMode), _SE(js_pipeline_RenderQueueDesc_set_sortMode));
cls->defineProperty("stages", _SE(js_pipeline_RenderQueueDesc_get_stages), _SE(js_pipeline_RenderQueueDesc_set_stages));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_RenderQueueDesc_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::RenderQueueDesc>(cls);
__jsb_cc_pipeline_RenderQueueDesc_proto = cls->getProto();
__jsb_cc_pipeline_RenderQueueDesc_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_RenderPipelineInfo_proto = nullptr;
se::Class* __jsb_cc_pipeline_RenderPipelineInfo_class = nullptr;
static bool js_pipeline_RenderPipelineInfo_get_tag(se::State& s)
{
cc::pipeline::RenderPipelineInfo* cobj = (cc::pipeline::RenderPipelineInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipelineInfo_get_tag : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= uint32_to_seval((unsigned int)cobj->tag, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderPipelineInfo_get_tag)
static bool js_pipeline_RenderPipelineInfo_set_tag(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderPipelineInfo* cobj = (cc::pipeline::RenderPipelineInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipelineInfo_set_tag : Invalid Native Object");
CC_UNUSED bool ok = true;
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderPipelineInfo_set_tag : Error processing new value");
cobj->tag = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderPipelineInfo_set_tag)
static bool js_pipeline_RenderPipelineInfo_get_flows(se::State& s)
{
cc::pipeline::RenderPipelineInfo* cobj = (cc::pipeline::RenderPipelineInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipelineInfo_get_flows : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= native_ptr_to_seval(cobj->flows, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderPipelineInfo_get_flows)
static bool js_pipeline_RenderPipelineInfo_set_flows(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderPipelineInfo* cobj = (cc::pipeline::RenderPipelineInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipelineInfo_set_flows : Invalid Native Object");
CC_UNUSED bool ok = true;
std::vector<cc::pipeline::RenderFlow *> arg0;
ok &= seval_to_std_vector(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderPipelineInfo_set_flows : Error processing new value");
cobj->flows = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderPipelineInfo_set_flows)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_RenderPipelineInfo_finalize)
static bool js_pipeline_RenderPipelineInfo_constructor(se::State& s)
{
CC_UNUSED bool ok = true;
const auto& args = s.args();
size_t argc = args.size();
if(argc == 0)
{
cc::pipeline::RenderPipelineInfo* cobj = JSB_ALLOC(cc::pipeline::RenderPipelineInfo);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
else if(argc == 1 && args[0].isObject())
{
se::Object *json = args[0].toObject();
se::Value field;
cc::pipeline::RenderPipelineInfo* cobj = JSB_ALLOC(cc::pipeline::RenderPipelineInfo);
unsigned int arg0 = 0;
json->getProperty("tag", &field);
if(!field.isUndefined()) {
ok &= seval_to_uint32(field, (uint32_t*)&arg0);
cobj->tag = arg0;
}
std::vector<cc::pipeline::RenderFlow *> arg1;
json->getProperty("flows", &field);
if(!field.isUndefined()) {
ok &= seval_to_std_vector(field, &arg1);
cobj->flows = arg1;
}
if(!ok) {
JSB_FREE(cobj);
SE_REPORT_ERROR("argument convertion error");
return false;
}
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
else
{
cc::pipeline::RenderPipelineInfo* cobj = JSB_ALLOC(cc::pipeline::RenderPipelineInfo);
if (argc > 0 && !args[0].isUndefined()) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
cobj->tag = arg0;
}
if (argc > 1 && !args[1].isUndefined()) {
std::vector<cc::pipeline::RenderFlow *> arg1;
ok &= seval_to_std_vector(args[1], &arg1);
cobj->flows = arg1;
}
if(!ok) {
JSB_FREE(cobj);
SE_REPORT_ERROR("Argument convertion error");
return false;
}
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
return false;
}
SE_BIND_CTOR(js_pipeline_RenderPipelineInfo_constructor, __jsb_cc_pipeline_RenderPipelineInfo_class, js_cc_pipeline_RenderPipelineInfo_finalize)
static bool js_cc_pipeline_RenderPipelineInfo_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::RenderPipelineInfo* cobj = (cc::pipeline::RenderPipelineInfo*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_RenderPipelineInfo_finalize)
bool js_register_pipeline_RenderPipelineInfo(se::Object* obj)
{
auto cls = se::Class::create("RenderPipelineInfo", obj, nullptr, _SE(js_pipeline_RenderPipelineInfo_constructor));
cls->defineProperty("tag", _SE(js_pipeline_RenderPipelineInfo_get_tag), _SE(js_pipeline_RenderPipelineInfo_set_tag));
cls->defineProperty("flows", _SE(js_pipeline_RenderPipelineInfo_get_flows), _SE(js_pipeline_RenderPipelineInfo_set_flows));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_RenderPipelineInfo_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::RenderPipelineInfo>(cls);
__jsb_cc_pipeline_RenderPipelineInfo_proto = cls->getProto();
__jsb_cc_pipeline_RenderPipelineInfo_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_RenderPipeline_proto = nullptr;
se::Class* __jsb_cc_pipeline_RenderPipeline_class = nullptr;
static bool js_pipeline_RenderPipeline_activate(se::State& s)
{
cc::pipeline::RenderPipeline* cobj = (cc::pipeline::RenderPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipeline_activate : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
bool result = cobj->activate();
ok &= boolean_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderPipeline_activate : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderPipeline_activate)
static bool js_pipeline_RenderPipeline_render(se::State& s)
{
cc::pipeline::RenderPipeline* cobj = (cc::pipeline::RenderPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipeline_render : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
std::vector<cc::pipeline::RenderView *> arg0;
ok &= seval_to_std_vector(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderPipeline_render : Error processing arguments");
cobj->render(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderPipeline_render)
static bool js_pipeline_RenderPipeline_getDescriptorSetLayout(se::State& s)
{
cc::pipeline::RenderPipeline* cobj = (cc::pipeline::RenderPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipeline_getDescriptorSetLayout : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::gfx::DescriptorSetLayout* result = cobj->getDescriptorSetLayout();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderPipeline_getDescriptorSetLayout : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_PROP_GET(js_pipeline_RenderPipeline_getDescriptorSetLayout)
static bool js_pipeline_RenderPipeline_setValue(se::State& s)
{
cc::pipeline::RenderPipeline* cobj = (cc::pipeline::RenderPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipeline_setValue : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 2) {
cc::String arg0;
bool arg1;
arg0 = args[0].toStringForce().c_str();
ok &= seval_to_boolean(args[1], &arg1);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderPipeline_setValue : Error processing arguments");
cobj->setValue(arg0, arg1);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderPipeline_setValue)
static bool js_pipeline_RenderPipeline_getDescriptorSet(se::State& s)
{
cc::pipeline::RenderPipeline* cobj = (cc::pipeline::RenderPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipeline_getDescriptorSet : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::gfx::DescriptorSet* result = cobj->getDescriptorSet();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderPipeline_getDescriptorSet : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_PROP_GET(js_pipeline_RenderPipeline_getDescriptorSet)
static bool js_pipeline_RenderPipeline_initialize(se::State& s)
{
cc::pipeline::RenderPipeline* cobj = (cc::pipeline::RenderPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipeline_initialize : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
cc::pipeline::RenderPipelineInfo* arg0 = nullptr;
ok &= seval_to_reference(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderPipeline_initialize : Error processing arguments");
bool result = cobj->initialize(*arg0);
ok &= boolean_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderPipeline_initialize : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderPipeline_initialize)
static bool js_pipeline_RenderPipeline_destroy(se::State& s)
{
cc::pipeline::RenderPipeline* cobj = (cc::pipeline::RenderPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderPipeline_destroy : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->destroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderPipeline_destroy)
static bool js_pipeline_RenderPipeline_getInstance(se::State& s)
{
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::pipeline::RenderPipeline* result = cc::pipeline::RenderPipeline::getInstance();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderPipeline_getInstance : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderPipeline_getInstance)
bool js_register_pipeline_RenderPipeline(se::Object* obj)
{
auto cls = se::Class::create("RenderPipeline", obj, nullptr, nullptr);
cls->defineProperty("descriptorSet", _SE(js_pipeline_RenderPipeline_getDescriptorSet), nullptr);
cls->defineProperty("descriptorSetLayout", _SE(js_pipeline_RenderPipeline_getDescriptorSetLayout), nullptr);
cls->defineFunction("activate", _SE(js_pipeline_RenderPipeline_activate));
cls->defineFunction("render", _SE(js_pipeline_RenderPipeline_render));
cls->defineFunction("setValue", _SE(js_pipeline_RenderPipeline_setValue));
cls->defineFunction("initialize", _SE(js_pipeline_RenderPipeline_initialize));
cls->defineFunction("destroy", _SE(js_pipeline_RenderPipeline_destroy));
cls->defineStaticFunction("getInstance", _SE(js_pipeline_RenderPipeline_getInstance));
cls->install();
JSBClassType::registerClass<cc::pipeline::RenderPipeline>(cls);
__jsb_cc_pipeline_RenderPipeline_proto = cls->getProto();
__jsb_cc_pipeline_RenderPipeline_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_ForwardPipeline_proto = nullptr;
se::Class* __jsb_cc_pipeline_ForwardPipeline_class = nullptr;
static bool js_pipeline_ForwardPipeline_setFog(se::State& s)
{
cc::pipeline::ForwardPipeline* cobj = (cc::pipeline::ForwardPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_ForwardPipeline_setFog : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_ForwardPipeline_setFog : Error processing arguments");
cobj->setFog(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_ForwardPipeline_setFog)
static bool js_pipeline_ForwardPipeline_getSphere(se::State& s)
{
cc::pipeline::ForwardPipeline* cobj = (cc::pipeline::ForwardPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_ForwardPipeline_getSphere : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::pipeline::Sphere* result = cobj->getSphere();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_ForwardPipeline_getSphere : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_ForwardPipeline_getSphere)
static bool js_pipeline_ForwardPipeline_getReceivedSphere(se::State& s)
{
cc::pipeline::ForwardPipeline* cobj = (cc::pipeline::ForwardPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_ForwardPipeline_getReceivedSphere : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::pipeline::Sphere* result = cobj->getReceivedSphere();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_ForwardPipeline_getReceivedSphere : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_ForwardPipeline_getReceivedSphere)
static bool js_pipeline_ForwardPipeline_setShadows(se::State& s)
{
cc::pipeline::ForwardPipeline* cobj = (cc::pipeline::ForwardPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_ForwardPipeline_setShadows : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_ForwardPipeline_setShadows : Error processing arguments");
cobj->setShadows(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_ForwardPipeline_setShadows)
static bool js_pipeline_ForwardPipeline_setSkybox(se::State& s)
{
cc::pipeline::ForwardPipeline* cobj = (cc::pipeline::ForwardPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_ForwardPipeline_setSkybox : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_ForwardPipeline_setSkybox : Error processing arguments");
cobj->setSkybox(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_ForwardPipeline_setSkybox)
static bool js_pipeline_ForwardPipeline_setAmbient(se::State& s)
{
cc::pipeline::ForwardPipeline* cobj = (cc::pipeline::ForwardPipeline*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_ForwardPipeline_setAmbient : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_ForwardPipeline_setAmbient : Error processing arguments");
cobj->setAmbient(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_ForwardPipeline_setAmbient)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_ForwardPipeline_finalize)
static bool js_pipeline_ForwardPipeline_constructor(se::State& s)
{
cc::pipeline::ForwardPipeline* cobj = JSB_ALLOC(cc::pipeline::ForwardPipeline);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_BIND_CTOR(js_pipeline_ForwardPipeline_constructor, __jsb_cc_pipeline_ForwardPipeline_class, js_cc_pipeline_ForwardPipeline_finalize)
extern se::Object* __jsb_cc_pipeline_RenderPipeline_proto;
static bool js_cc_pipeline_ForwardPipeline_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::ForwardPipeline* cobj = (cc::pipeline::ForwardPipeline*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_ForwardPipeline_finalize)
bool js_register_pipeline_ForwardPipeline(se::Object* obj)
{
auto cls = se::Class::create("ForwardPipeline", obj, __jsb_cc_pipeline_RenderPipeline_proto, _SE(js_pipeline_ForwardPipeline_constructor));
cls->defineFunction("setFog", _SE(js_pipeline_ForwardPipeline_setFog));
cls->defineFunction("getSphere", _SE(js_pipeline_ForwardPipeline_getSphere));
cls->defineFunction("getReceivedSphere", _SE(js_pipeline_ForwardPipeline_getReceivedSphere));
cls->defineFunction("setShadows", _SE(js_pipeline_ForwardPipeline_setShadows));
cls->defineFunction("setSkybox", _SE(js_pipeline_ForwardPipeline_setSkybox));
cls->defineFunction("setAmbient", _SE(js_pipeline_ForwardPipeline_setAmbient));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_ForwardPipeline_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::ForwardPipeline>(cls);
__jsb_cc_pipeline_ForwardPipeline_proto = cls->getProto();
__jsb_cc_pipeline_ForwardPipeline_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_RenderFlowInfo_proto = nullptr;
se::Class* __jsb_cc_pipeline_RenderFlowInfo_class = nullptr;
static bool js_pipeline_RenderFlowInfo_get_name(se::State& s)
{
cc::pipeline::RenderFlowInfo* cobj = (cc::pipeline::RenderFlowInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlowInfo_get_name : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
jsret.setString(cobj->name);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderFlowInfo_get_name)
static bool js_pipeline_RenderFlowInfo_set_name(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderFlowInfo* cobj = (cc::pipeline::RenderFlowInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlowInfo_set_name : Invalid Native Object");
CC_UNUSED bool ok = true;
cc::String arg0;
arg0 = args[0].toStringForce().c_str();
SE_PRECONDITION2(ok, false, "js_pipeline_RenderFlowInfo_set_name : Error processing new value");
cobj->name = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderFlowInfo_set_name)
static bool js_pipeline_RenderFlowInfo_get_priority(se::State& s)
{
cc::pipeline::RenderFlowInfo* cobj = (cc::pipeline::RenderFlowInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlowInfo_get_priority : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= uint32_to_seval((unsigned int)cobj->priority, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderFlowInfo_get_priority)
static bool js_pipeline_RenderFlowInfo_set_priority(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderFlowInfo* cobj = (cc::pipeline::RenderFlowInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlowInfo_set_priority : Invalid Native Object");
CC_UNUSED bool ok = true;
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderFlowInfo_set_priority : Error processing new value");
cobj->priority = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderFlowInfo_set_priority)
static bool js_pipeline_RenderFlowInfo_get_tag(se::State& s)
{
cc::pipeline::RenderFlowInfo* cobj = (cc::pipeline::RenderFlowInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlowInfo_get_tag : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= uint32_to_seval((unsigned int)cobj->tag, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderFlowInfo_get_tag)
static bool js_pipeline_RenderFlowInfo_set_tag(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderFlowInfo* cobj = (cc::pipeline::RenderFlowInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlowInfo_set_tag : Invalid Native Object");
CC_UNUSED bool ok = true;
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderFlowInfo_set_tag : Error processing new value");
cobj->tag = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderFlowInfo_set_tag)
static bool js_pipeline_RenderFlowInfo_get_stages(se::State& s)
{
cc::pipeline::RenderFlowInfo* cobj = (cc::pipeline::RenderFlowInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlowInfo_get_stages : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= native_ptr_to_seval(cobj->stages, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderFlowInfo_get_stages)
static bool js_pipeline_RenderFlowInfo_set_stages(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderFlowInfo* cobj = (cc::pipeline::RenderFlowInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlowInfo_set_stages : Invalid Native Object");
CC_UNUSED bool ok = true;
std::vector<cc::pipeline::RenderStage *> arg0;
ok &= seval_to_std_vector(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderFlowInfo_set_stages : Error processing new value");
cobj->stages = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderFlowInfo_set_stages)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_RenderFlowInfo_finalize)
static bool js_pipeline_RenderFlowInfo_constructor(se::State& s)
{
CC_UNUSED bool ok = true;
const auto& args = s.args();
size_t argc = args.size();
if(argc == 0)
{
cc::pipeline::RenderFlowInfo* cobj = JSB_ALLOC(cc::pipeline::RenderFlowInfo);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
else if(argc == 1 && args[0].isObject())
{
se::Object *json = args[0].toObject();
se::Value field;
cc::pipeline::RenderFlowInfo* cobj = JSB_ALLOC(cc::pipeline::RenderFlowInfo);
cc::String arg0;
json->getProperty("name", &field);
if(!field.isUndefined()) {
arg0 = field.toStringForce().c_str();
cobj->name = arg0;
}
unsigned int arg1 = 0;
json->getProperty("priority", &field);
if(!field.isUndefined()) {
ok &= seval_to_uint32(field, (uint32_t*)&arg1);
cobj->priority = arg1;
}
unsigned int arg2 = 0;
json->getProperty("tag", &field);
if(!field.isUndefined()) {
ok &= seval_to_uint32(field, (uint32_t*)&arg2);
cobj->tag = arg2;
}
std::vector<cc::pipeline::RenderStage *> arg3;
json->getProperty("stages", &field);
if(!field.isUndefined()) {
ok &= seval_to_std_vector(field, &arg3);
cobj->stages = arg3;
}
if(!ok) {
JSB_FREE(cobj);
SE_REPORT_ERROR("argument convertion error");
return false;
}
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
else
{
cc::pipeline::RenderFlowInfo* cobj = JSB_ALLOC(cc::pipeline::RenderFlowInfo);
if (argc > 0 && !args[0].isUndefined()) {
cc::String arg0;
arg0 = args[0].toStringForce().c_str();
cobj->name = arg0;
}
if (argc > 1 && !args[1].isUndefined()) {
unsigned int arg1 = 0;
ok &= seval_to_uint32(args[1], (uint32_t*)&arg1);
cobj->priority = arg1;
}
if (argc > 2 && !args[2].isUndefined()) {
unsigned int arg2 = 0;
ok &= seval_to_uint32(args[2], (uint32_t*)&arg2);
cobj->tag = arg2;
}
if (argc > 3 && !args[3].isUndefined()) {
std::vector<cc::pipeline::RenderStage *> arg3;
ok &= seval_to_std_vector(args[3], &arg3);
cobj->stages = arg3;
}
if(!ok) {
JSB_FREE(cobj);
SE_REPORT_ERROR("Argument convertion error");
return false;
}
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
return false;
}
SE_BIND_CTOR(js_pipeline_RenderFlowInfo_constructor, __jsb_cc_pipeline_RenderFlowInfo_class, js_cc_pipeline_RenderFlowInfo_finalize)
static bool js_cc_pipeline_RenderFlowInfo_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::RenderFlowInfo* cobj = (cc::pipeline::RenderFlowInfo*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_RenderFlowInfo_finalize)
bool js_register_pipeline_RenderFlowInfo(se::Object* obj)
{
auto cls = se::Class::create("RenderFlowInfo", obj, nullptr, _SE(js_pipeline_RenderFlowInfo_constructor));
cls->defineProperty("name", _SE(js_pipeline_RenderFlowInfo_get_name), _SE(js_pipeline_RenderFlowInfo_set_name));
cls->defineProperty("priority", _SE(js_pipeline_RenderFlowInfo_get_priority), _SE(js_pipeline_RenderFlowInfo_set_priority));
cls->defineProperty("tag", _SE(js_pipeline_RenderFlowInfo_get_tag), _SE(js_pipeline_RenderFlowInfo_set_tag));
cls->defineProperty("stages", _SE(js_pipeline_RenderFlowInfo_get_stages), _SE(js_pipeline_RenderFlowInfo_set_stages));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_RenderFlowInfo_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::RenderFlowInfo>(cls);
__jsb_cc_pipeline_RenderFlowInfo_proto = cls->getProto();
__jsb_cc_pipeline_RenderFlowInfo_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_RenderFlow_proto = nullptr;
se::Class* __jsb_cc_pipeline_RenderFlow_class = nullptr;
static bool js_pipeline_RenderFlow_activate(se::State& s)
{
cc::pipeline::RenderFlow* cobj = (cc::pipeline::RenderFlow*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlow_activate : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
cc::pipeline::RenderPipeline* arg0 = nullptr;
ok &= seval_to_native_ptr(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderFlow_activate : Error processing arguments");
cobj->activate(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderFlow_activate)
static bool js_pipeline_RenderFlow_initialize(se::State& s)
{
cc::pipeline::RenderFlow* cobj = (cc::pipeline::RenderFlow*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlow_initialize : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
cc::pipeline::RenderFlowInfo* arg0 = nullptr;
ok &= seval_to_reference(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderFlow_initialize : Error processing arguments");
bool result = cobj->initialize(*arg0);
ok &= boolean_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderFlow_initialize : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderFlow_initialize)
static bool js_pipeline_RenderFlow_getTag(se::State& s)
{
cc::pipeline::RenderFlow* cobj = (cc::pipeline::RenderFlow*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderFlow_getTag : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getTag();
ok &= uint32_to_seval((unsigned int)result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderFlow_getTag : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderFlow_getTag)
bool js_register_pipeline_RenderFlow(se::Object* obj)
{
auto cls = se::Class::create("RenderFlow", obj, nullptr, nullptr);
cls->defineFunction("activate", _SE(js_pipeline_RenderFlow_activate));
cls->defineFunction("initialize", _SE(js_pipeline_RenderFlow_initialize));
cls->defineFunction("getTag", _SE(js_pipeline_RenderFlow_getTag));
cls->install();
JSBClassType::registerClass<cc::pipeline::RenderFlow>(cls);
__jsb_cc_pipeline_RenderFlow_proto = cls->getProto();
__jsb_cc_pipeline_RenderFlow_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_ForwardFlow_proto = nullptr;
se::Class* __jsb_cc_pipeline_ForwardFlow_class = nullptr;
static bool js_pipeline_ForwardFlow_getInitializeInfo(se::State& s)
{
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
const cc::pipeline::RenderFlowInfo& result = cc::pipeline::ForwardFlow::getInitializeInfo();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_ForwardFlow_getInitializeInfo : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_ForwardFlow_getInitializeInfo)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_ForwardFlow_finalize)
static bool js_pipeline_ForwardFlow_constructor(se::State& s)
{
cc::pipeline::ForwardFlow* cobj = JSB_ALLOC(cc::pipeline::ForwardFlow);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_BIND_CTOR(js_pipeline_ForwardFlow_constructor, __jsb_cc_pipeline_ForwardFlow_class, js_cc_pipeline_ForwardFlow_finalize)
extern se::Object* __jsb_cc_pipeline_RenderFlow_proto;
static bool js_cc_pipeline_ForwardFlow_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::ForwardFlow* cobj = (cc::pipeline::ForwardFlow*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_ForwardFlow_finalize)
bool js_register_pipeline_ForwardFlow(se::Object* obj)
{
auto cls = se::Class::create("ForwardFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_pipeline_ForwardFlow_constructor));
cls->defineStaticFunction("getInitializeInfo", _SE(js_pipeline_ForwardFlow_getInitializeInfo));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_ForwardFlow_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::ForwardFlow>(cls);
__jsb_cc_pipeline_ForwardFlow_proto = cls->getProto();
__jsb_cc_pipeline_ForwardFlow_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_RenderStageInfo_proto = nullptr;
se::Class* __jsb_cc_pipeline_RenderStageInfo_class = nullptr;
static bool js_pipeline_RenderStageInfo_get_name(se::State& s)
{
cc::pipeline::RenderStageInfo* cobj = (cc::pipeline::RenderStageInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStageInfo_get_name : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
jsret.setString(cobj->name);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderStageInfo_get_name)
static bool js_pipeline_RenderStageInfo_set_name(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderStageInfo* cobj = (cc::pipeline::RenderStageInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStageInfo_set_name : Invalid Native Object");
CC_UNUSED bool ok = true;
cc::String arg0;
arg0 = args[0].toStringForce().c_str();
SE_PRECONDITION2(ok, false, "js_pipeline_RenderStageInfo_set_name : Error processing new value");
cobj->name = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderStageInfo_set_name)
static bool js_pipeline_RenderStageInfo_get_priority(se::State& s)
{
cc::pipeline::RenderStageInfo* cobj = (cc::pipeline::RenderStageInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStageInfo_get_priority : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= uint32_to_seval((unsigned int)cobj->priority, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderStageInfo_get_priority)
static bool js_pipeline_RenderStageInfo_set_priority(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderStageInfo* cobj = (cc::pipeline::RenderStageInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStageInfo_set_priority : Invalid Native Object");
CC_UNUSED bool ok = true;
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderStageInfo_set_priority : Error processing new value");
cobj->priority = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderStageInfo_set_priority)
static bool js_pipeline_RenderStageInfo_get_tag(se::State& s)
{
cc::pipeline::RenderStageInfo* cobj = (cc::pipeline::RenderStageInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStageInfo_get_tag : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= uint32_to_seval((unsigned int)cobj->tag, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderStageInfo_get_tag)
static bool js_pipeline_RenderStageInfo_set_tag(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderStageInfo* cobj = (cc::pipeline::RenderStageInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStageInfo_set_tag : Invalid Native Object");
CC_UNUSED bool ok = true;
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderStageInfo_set_tag : Error processing new value");
cobj->tag = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderStageInfo_set_tag)
static bool js_pipeline_RenderStageInfo_get_renderQueues(se::State& s)
{
cc::pipeline::RenderStageInfo* cobj = (cc::pipeline::RenderStageInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStageInfo_get_renderQueues : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= native_ptr_to_seval(cobj->renderQueues, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderStageInfo_get_renderQueues)
static bool js_pipeline_RenderStageInfo_set_renderQueues(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderStageInfo* cobj = (cc::pipeline::RenderStageInfo*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStageInfo_set_renderQueues : Invalid Native Object");
CC_UNUSED bool ok = true;
std::vector<cc::pipeline::RenderQueueDesc> arg0;
ok &= seval_to_std_vector(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderStageInfo_set_renderQueues : Error processing new value");
cobj->renderQueues = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderStageInfo_set_renderQueues)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_RenderStageInfo_finalize)
static bool js_pipeline_RenderStageInfo_constructor(se::State& s)
{
CC_UNUSED bool ok = true;
const auto& args = s.args();
size_t argc = args.size();
if(argc == 0)
{
cc::pipeline::RenderStageInfo* cobj = JSB_ALLOC(cc::pipeline::RenderStageInfo);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
else if(argc == 1 && args[0].isObject())
{
se::Object *json = args[0].toObject();
se::Value field;
cc::pipeline::RenderStageInfo* cobj = JSB_ALLOC(cc::pipeline::RenderStageInfo);
cc::String arg0;
json->getProperty("name", &field);
if(!field.isUndefined()) {
arg0 = field.toStringForce().c_str();
cobj->name = arg0;
}
unsigned int arg1 = 0;
json->getProperty("priority", &field);
if(!field.isUndefined()) {
ok &= seval_to_uint32(field, (uint32_t*)&arg1);
cobj->priority = arg1;
}
unsigned int arg2 = 0;
json->getProperty("tag", &field);
if(!field.isUndefined()) {
ok &= seval_to_uint32(field, (uint32_t*)&arg2);
cobj->tag = arg2;
}
std::vector<cc::pipeline::RenderQueueDesc> arg3;
json->getProperty("renderQueues", &field);
if(!field.isUndefined()) {
ok &= seval_to_std_vector(field, &arg3);
cobj->renderQueues = arg3;
}
if(!ok) {
JSB_FREE(cobj);
SE_REPORT_ERROR("argument convertion error");
return false;
}
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
else
{
cc::pipeline::RenderStageInfo* cobj = JSB_ALLOC(cc::pipeline::RenderStageInfo);
if (argc > 0 && !args[0].isUndefined()) {
cc::String arg0;
arg0 = args[0].toStringForce().c_str();
cobj->name = arg0;
}
if (argc > 1 && !args[1].isUndefined()) {
unsigned int arg1 = 0;
ok &= seval_to_uint32(args[1], (uint32_t*)&arg1);
cobj->priority = arg1;
}
if (argc > 2 && !args[2].isUndefined()) {
unsigned int arg2 = 0;
ok &= seval_to_uint32(args[2], (uint32_t*)&arg2);
cobj->tag = arg2;
}
if (argc > 3 && !args[3].isUndefined()) {
std::vector<cc::pipeline::RenderQueueDesc> arg3;
ok &= seval_to_std_vector(args[3], &arg3);
cobj->renderQueues = arg3;
}
if(!ok) {
JSB_FREE(cobj);
SE_REPORT_ERROR("Argument convertion error");
return false;
}
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
return false;
}
SE_BIND_CTOR(js_pipeline_RenderStageInfo_constructor, __jsb_cc_pipeline_RenderStageInfo_class, js_cc_pipeline_RenderStageInfo_finalize)
static bool js_cc_pipeline_RenderStageInfo_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::RenderStageInfo* cobj = (cc::pipeline::RenderStageInfo*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_RenderStageInfo_finalize)
bool js_register_pipeline_RenderStageInfo(se::Object* obj)
{
auto cls = se::Class::create("RenderStageInfo", obj, nullptr, _SE(js_pipeline_RenderStageInfo_constructor));
cls->defineProperty("name", _SE(js_pipeline_RenderStageInfo_get_name), _SE(js_pipeline_RenderStageInfo_set_name));
cls->defineProperty("priority", _SE(js_pipeline_RenderStageInfo_get_priority), _SE(js_pipeline_RenderStageInfo_set_priority));
cls->defineProperty("tag", _SE(js_pipeline_RenderStageInfo_get_tag), _SE(js_pipeline_RenderStageInfo_set_tag));
cls->defineProperty("renderQueues", _SE(js_pipeline_RenderStageInfo_get_renderQueues), _SE(js_pipeline_RenderStageInfo_set_renderQueues));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_RenderStageInfo_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::RenderStageInfo>(cls);
__jsb_cc_pipeline_RenderStageInfo_proto = cls->getProto();
__jsb_cc_pipeline_RenderStageInfo_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_RenderStage_proto = nullptr;
se::Class* __jsb_cc_pipeline_RenderStage_class = nullptr;
static bool js_pipeline_RenderStage_activate(se::State& s)
{
cc::pipeline::RenderStage* cobj = (cc::pipeline::RenderStage*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStage_activate : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 2) {
cc::pipeline::RenderPipeline* arg0 = nullptr;
cc::pipeline::RenderFlow* arg1 = nullptr;
ok &= seval_to_native_ptr(args[0], &arg0);
ok &= seval_to_native_ptr(args[1], &arg1);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderStage_activate : Error processing arguments");
cobj->activate(arg0, arg1);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderStage_activate)
static bool js_pipeline_RenderStage_initialize(se::State& s)
{
cc::pipeline::RenderStage* cobj = (cc::pipeline::RenderStage*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStage_initialize : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
cc::pipeline::RenderStageInfo* arg0 = nullptr;
ok &= seval_to_reference(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderStage_initialize : Error processing arguments");
bool result = cobj->initialize(*arg0);
ok &= boolean_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderStage_initialize : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderStage_initialize)
static bool js_pipeline_RenderStage_getTag(se::State& s)
{
cc::pipeline::RenderStage* cobj = (cc::pipeline::RenderStage*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderStage_getTag : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getTag();
ok &= uint32_to_seval((unsigned int)result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderStage_getTag : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderStage_getTag)
bool js_register_pipeline_RenderStage(se::Object* obj)
{
auto cls = se::Class::create("RenderStage", obj, nullptr, nullptr);
cls->defineFunction("activate", _SE(js_pipeline_RenderStage_activate));
cls->defineFunction("initialize", _SE(js_pipeline_RenderStage_initialize));
cls->defineFunction("getTag", _SE(js_pipeline_RenderStage_getTag));
cls->install();
JSBClassType::registerClass<cc::pipeline::RenderStage>(cls);
__jsb_cc_pipeline_RenderStage_proto = cls->getProto();
__jsb_cc_pipeline_RenderStage_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_ForwardStage_proto = nullptr;
se::Class* __jsb_cc_pipeline_ForwardStage_class = nullptr;
static bool js_pipeline_ForwardStage_getInitializeInfo(se::State& s)
{
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
const cc::pipeline::RenderStageInfo& result = cc::pipeline::ForwardStage::getInitializeInfo();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_ForwardStage_getInitializeInfo : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_ForwardStage_getInitializeInfo)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_ForwardStage_finalize)
static bool js_pipeline_ForwardStage_constructor(se::State& s)
{
cc::pipeline::ForwardStage* cobj = JSB_ALLOC(cc::pipeline::ForwardStage);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_BIND_CTOR(js_pipeline_ForwardStage_constructor, __jsb_cc_pipeline_ForwardStage_class, js_cc_pipeline_ForwardStage_finalize)
extern se::Object* __jsb_cc_pipeline_RenderStage_proto;
static bool js_cc_pipeline_ForwardStage_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::ForwardStage* cobj = (cc::pipeline::ForwardStage*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_ForwardStage_finalize)
bool js_register_pipeline_ForwardStage(se::Object* obj)
{
auto cls = se::Class::create("ForwardStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_pipeline_ForwardStage_constructor));
cls->defineStaticFunction("getInitializeInfo", _SE(js_pipeline_ForwardStage_getInitializeInfo));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_ForwardStage_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::ForwardStage>(cls);
__jsb_cc_pipeline_ForwardStage_proto = cls->getProto();
__jsb_cc_pipeline_ForwardStage_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_ShadowFlow_proto = nullptr;
se::Class* __jsb_cc_pipeline_ShadowFlow_class = nullptr;
static bool js_pipeline_ShadowFlow_getInitializeInfo(se::State& s)
{
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
const cc::pipeline::RenderFlowInfo& result = cc::pipeline::ShadowFlow::getInitializeInfo();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_ShadowFlow_getInitializeInfo : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_ShadowFlow_getInitializeInfo)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_ShadowFlow_finalize)
static bool js_pipeline_ShadowFlow_constructor(se::State& s)
{
cc::pipeline::ShadowFlow* cobj = JSB_ALLOC(cc::pipeline::ShadowFlow);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_BIND_CTOR(js_pipeline_ShadowFlow_constructor, __jsb_cc_pipeline_ShadowFlow_class, js_cc_pipeline_ShadowFlow_finalize)
extern se::Object* __jsb_cc_pipeline_RenderFlow_proto;
static bool js_cc_pipeline_ShadowFlow_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::ShadowFlow* cobj = (cc::pipeline::ShadowFlow*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_ShadowFlow_finalize)
bool js_register_pipeline_ShadowFlow(se::Object* obj)
{
auto cls = se::Class::create("ShadowFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_pipeline_ShadowFlow_constructor));
cls->defineStaticFunction("getInitializeInfo", _SE(js_pipeline_ShadowFlow_getInitializeInfo));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_ShadowFlow_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::ShadowFlow>(cls);
__jsb_cc_pipeline_ShadowFlow_proto = cls->getProto();
__jsb_cc_pipeline_ShadowFlow_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_ShadowStage_proto = nullptr;
se::Class* __jsb_cc_pipeline_ShadowStage_class = nullptr;
static bool js_pipeline_ShadowStage_setFramebuffer(se::State& s)
{
cc::pipeline::ShadowStage* cobj = (cc::pipeline::ShadowStage*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_ShadowStage_setFramebuffer : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
cc::gfx::Framebuffer* arg0 = nullptr;
ok &= seval_to_native_ptr(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_ShadowStage_setFramebuffer : Error processing arguments");
cobj->setFramebuffer(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_ShadowStage_setFramebuffer)
static bool js_pipeline_ShadowStage_getInitializeInfo(se::State& s)
{
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
const cc::pipeline::RenderStageInfo& result = cc::pipeline::ShadowStage::getInitializeInfo();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_ShadowStage_getInitializeInfo : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_ShadowStage_getInitializeInfo)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_ShadowStage_finalize)
static bool js_pipeline_ShadowStage_constructor(se::State& s)
{
cc::pipeline::ShadowStage* cobj = JSB_ALLOC(cc::pipeline::ShadowStage);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_BIND_CTOR(js_pipeline_ShadowStage_constructor, __jsb_cc_pipeline_ShadowStage_class, js_cc_pipeline_ShadowStage_finalize)
extern se::Object* __jsb_cc_pipeline_RenderStage_proto;
static bool js_cc_pipeline_ShadowStage_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::ShadowStage* cobj = (cc::pipeline::ShadowStage*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_ShadowStage_finalize)
bool js_register_pipeline_ShadowStage(se::Object* obj)
{
auto cls = se::Class::create("ShadowStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_pipeline_ShadowStage_constructor));
cls->defineFunction("setFramebuffer", _SE(js_pipeline_ShadowStage_setFramebuffer));
cls->defineStaticFunction("getInitializeInfo", _SE(js_pipeline_ShadowStage_getInitializeInfo));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_ShadowStage_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::ShadowStage>(cls);
__jsb_cc_pipeline_ShadowStage_proto = cls->getProto();
__jsb_cc_pipeline_ShadowStage_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_UIFlow_proto = nullptr;
se::Class* __jsb_cc_pipeline_UIFlow_class = nullptr;
static bool js_pipeline_UIFlow_getInitializeInfo(se::State& s)
{
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
const cc::pipeline::RenderFlowInfo& result = cc::pipeline::UIFlow::getInitializeInfo();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_UIFlow_getInitializeInfo : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_UIFlow_getInitializeInfo)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_UIFlow_finalize)
static bool js_pipeline_UIFlow_constructor(se::State& s)
{
cc::pipeline::UIFlow* cobj = JSB_ALLOC(cc::pipeline::UIFlow);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_BIND_CTOR(js_pipeline_UIFlow_constructor, __jsb_cc_pipeline_UIFlow_class, js_cc_pipeline_UIFlow_finalize)
extern se::Object* __jsb_cc_pipeline_RenderFlow_proto;
static bool js_cc_pipeline_UIFlow_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::UIFlow* cobj = (cc::pipeline::UIFlow*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_UIFlow_finalize)
bool js_register_pipeline_UIFlow(se::Object* obj)
{
auto cls = se::Class::create("UIFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_pipeline_UIFlow_constructor));
cls->defineStaticFunction("getInitializeInfo", _SE(js_pipeline_UIFlow_getInitializeInfo));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_UIFlow_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::UIFlow>(cls);
__jsb_cc_pipeline_UIFlow_proto = cls->getProto();
__jsb_cc_pipeline_UIFlow_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_UIStage_proto = nullptr;
se::Class* __jsb_cc_pipeline_UIStage_class = nullptr;
static bool js_pipeline_UIStage_getInitializeInfo(se::State& s)
{
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
const cc::pipeline::RenderStageInfo& result = cc::pipeline::UIStage::getInitializeInfo();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_UIStage_getInitializeInfo : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_UIStage_getInitializeInfo)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_UIStage_finalize)
static bool js_pipeline_UIStage_constructor(se::State& s)
{
cc::pipeline::UIStage* cobj = JSB_ALLOC(cc::pipeline::UIStage);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_BIND_CTOR(js_pipeline_UIStage_constructor, __jsb_cc_pipeline_UIStage_class, js_cc_pipeline_UIStage_finalize)
extern se::Object* __jsb_cc_pipeline_RenderStage_proto;
static bool js_cc_pipeline_UIStage_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::UIStage* cobj = (cc::pipeline::UIStage*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_UIStage_finalize)
bool js_register_pipeline_UIStage(se::Object* obj)
{
auto cls = se::Class::create("UIStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_pipeline_UIStage_constructor));
cls->defineStaticFunction("getInitializeInfo", _SE(js_pipeline_UIStage_getInitializeInfo));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_UIStage_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::UIStage>(cls);
__jsb_cc_pipeline_UIStage_proto = cls->getProto();
__jsb_cc_pipeline_UIStage_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_RenderView_proto = nullptr;
se::Class* __jsb_cc_pipeline_RenderView_class = nullptr;
static bool js_pipeline_RenderView_setEnable(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_setEnable : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
bool arg0;
ok &= seval_to_boolean(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_setEnable : Error processing arguments");
cobj->setEnable(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderView_setEnable)
static bool js_pipeline_RenderView_setExecuteFlows(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_setExecuteFlows : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
std::vector<std::string> arg0;
ok &= seval_to_std_vector_string(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_setExecuteFlows : Error processing arguments");
cobj->setExecuteFlows(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderView_setExecuteFlows)
static bool js_pipeline_RenderView_onGlobalPipelineStateChanged(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_onGlobalPipelineStateChanged : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->onGlobalPipelineStateChanged();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderView_onGlobalPipelineStateChanged)
static bool js_pipeline_RenderView_getName(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_getName : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
const cc::String& result = cobj->getName();
s.rval().setString(result);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_getName : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_PROP_GET(js_pipeline_RenderView_getName)
static bool js_pipeline_RenderView_getPriority(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_getPriority : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getPriority();
ok &= uint32_to_seval((unsigned int)result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_getPriority : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_PROP_GET(js_pipeline_RenderView_getPriority)
static bool js_pipeline_RenderView_getVisibility(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_getVisibility : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
unsigned int result = cobj->getVisibility();
ok &= uint32_to_seval((unsigned int)result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_getVisibility : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderView_getVisibility)
static bool js_pipeline_RenderView_setPriority(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_setPriority : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_setPriority : Error processing arguments");
cobj->setPriority(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_PROP_SET(js_pipeline_RenderView_setPriority)
static bool js_pipeline_RenderView_setVisibility(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_setVisibility : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_setVisibility : Error processing arguments");
cobj->setVisibility(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderView_setVisibility)
static bool js_pipeline_RenderView_getWindow(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_getWindow : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::pipeline::RenderWindow* result = cobj->getWindow();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_getWindow : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderView_getWindow)
static bool js_pipeline_RenderView_initialize(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_initialize : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
cc::pipeline::RenderViewInfo* arg0 = nullptr;
ok &= seval_to_reference(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_initialize : Error processing arguments");
bool result = cobj->initialize(*arg0);
ok &= boolean_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_initialize : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderView_initialize)
static bool js_pipeline_RenderView_destroy(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_destroy : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->destroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderView_destroy)
static bool js_pipeline_RenderView_getFlows(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_getFlows : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
const std::vector<cc::pipeline::RenderFlow *>& result = cobj->getFlows();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_getFlows : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderView_getFlows)
static bool js_pipeline_RenderView_setWindow(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_setWindow : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_setWindow : Error processing arguments");
cobj->setWindow(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderView_setWindow)
static bool js_pipeline_RenderView_isEnabled(se::State& s)
{
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderView_isEnabled : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
bool result = cobj->isEnabled();
ok &= boolean_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderView_isEnabled : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_PROP_GET(js_pipeline_RenderView_isEnabled)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_RenderView_finalize)
static bool js_pipeline_RenderView_constructor(se::State& s)
{
cc::pipeline::RenderView* cobj = JSB_ALLOC(cc::pipeline::RenderView);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_BIND_CTOR(js_pipeline_RenderView_constructor, __jsb_cc_pipeline_RenderView_class, js_cc_pipeline_RenderView_finalize)
static bool js_cc_pipeline_RenderView_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::RenderView* cobj = (cc::pipeline::RenderView*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_RenderView_finalize)
bool js_register_pipeline_RenderView(se::Object* obj)
{
auto cls = se::Class::create("RenderView", obj, nullptr, _SE(js_pipeline_RenderView_constructor));
cls->defineProperty("priority", _SE(js_pipeline_RenderView_getPriority), _SE(js_pipeline_RenderView_setPriority));
cls->defineProperty("name", _SE(js_pipeline_RenderView_getName), nullptr);
cls->defineProperty("isEnable", _SE(js_pipeline_RenderView_isEnabled), nullptr);
cls->defineFunction("enable", _SE(js_pipeline_RenderView_setEnable));
cls->defineFunction("setExecuteFlows", _SE(js_pipeline_RenderView_setExecuteFlows));
cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_pipeline_RenderView_onGlobalPipelineStateChanged));
cls->defineFunction("getVisibility", _SE(js_pipeline_RenderView_getVisibility));
cls->defineFunction("setVisibility", _SE(js_pipeline_RenderView_setVisibility));
cls->defineFunction("getWindow", _SE(js_pipeline_RenderView_getWindow));
cls->defineFunction("initialize", _SE(js_pipeline_RenderView_initialize));
cls->defineFunction("destroy", _SE(js_pipeline_RenderView_destroy));
cls->defineFunction("getFlows", _SE(js_pipeline_RenderView_getFlows));
cls->defineFunction("setWindow", _SE(js_pipeline_RenderView_setWindow));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_RenderView_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::RenderView>(cls);
__jsb_cc_pipeline_RenderView_proto = cls->getProto();
__jsb_cc_pipeline_RenderView_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_RenderWindow_proto = nullptr;
se::Class* __jsb_cc_pipeline_RenderWindow_class = nullptr;
static bool js_pipeline_RenderWindow_getFramebuffer(se::State& s)
{
cc::pipeline::RenderWindow* cobj = (cc::pipeline::RenderWindow*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderWindow_getFramebuffer : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 0) {
cc::gfx::Framebuffer* result = cobj->getFramebuffer();
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_RenderWindow_getFramebuffer : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_RenderWindow_getFramebuffer)
static bool js_pipeline_RenderWindow_get_hasOnScreenAttachments(se::State& s)
{
cc::pipeline::RenderWindow* cobj = (cc::pipeline::RenderWindow*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderWindow_get_hasOnScreenAttachments : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= uint32_to_seval((unsigned int)cobj->hasOnScreenAttachments, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderWindow_get_hasOnScreenAttachments)
static bool js_pipeline_RenderWindow_set_hasOnScreenAttachments(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderWindow* cobj = (cc::pipeline::RenderWindow*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderWindow_set_hasOnScreenAttachments : Invalid Native Object");
CC_UNUSED bool ok = true;
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderWindow_set_hasOnScreenAttachments : Error processing new value");
cobj->hasOnScreenAttachments = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderWindow_set_hasOnScreenAttachments)
static bool js_pipeline_RenderWindow_get_hasOffScreenAttachments(se::State& s)
{
cc::pipeline::RenderWindow* cobj = (cc::pipeline::RenderWindow*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderWindow_get_hasOffScreenAttachments : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= uint32_to_seval((unsigned int)cobj->hasOffScreenAttachments, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderWindow_get_hasOffScreenAttachments)
static bool js_pipeline_RenderWindow_set_hasOffScreenAttachments(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderWindow* cobj = (cc::pipeline::RenderWindow*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderWindow_set_hasOffScreenAttachments : Invalid Native Object");
CC_UNUSED bool ok = true;
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderWindow_set_hasOffScreenAttachments : Error processing new value");
cobj->hasOffScreenAttachments = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderWindow_set_hasOffScreenAttachments)
static bool js_pipeline_RenderWindow_get_framebufferID(se::State& s)
{
cc::pipeline::RenderWindow* cobj = (cc::pipeline::RenderWindow*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderWindow_get_framebufferID : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= uint32_to_seval((unsigned int)cobj->framebufferID, &jsret);
s.rval() = jsret;
return true;
}
SE_BIND_PROP_GET(js_pipeline_RenderWindow_get_framebufferID)
static bool js_pipeline_RenderWindow_set_framebufferID(se::State& s)
{
const auto& args = s.args();
cc::pipeline::RenderWindow* cobj = (cc::pipeline::RenderWindow*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_RenderWindow_set_framebufferID : Invalid Native Object");
CC_UNUSED bool ok = true;
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_RenderWindow_set_framebufferID : Error processing new value");
cobj->framebufferID = arg0;
return true;
}
SE_BIND_PROP_SET(js_pipeline_RenderWindow_set_framebufferID)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_RenderWindow_finalize)
static bool js_pipeline_RenderWindow_constructor(se::State& s)
{
CC_UNUSED bool ok = true;
const auto& args = s.args();
size_t argc = args.size();
if(argc == 0)
{
cc::pipeline::RenderWindow* cobj = JSB_ALLOC(cc::pipeline::RenderWindow);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
else if(argc == 1 && args[0].isObject())
{
se::Object *json = args[0].toObject();
se::Value field;
cc::pipeline::RenderWindow* cobj = JSB_ALLOC(cc::pipeline::RenderWindow);
unsigned int arg0 = 0;
json->getProperty("hasOnScreenAttachments", &field);
if(!field.isUndefined()) {
ok &= seval_to_uint32(field, (uint32_t*)&arg0);
cobj->hasOnScreenAttachments = arg0;
}
unsigned int arg1 = 0;
json->getProperty("hasOffScreenAttachments", &field);
if(!field.isUndefined()) {
ok &= seval_to_uint32(field, (uint32_t*)&arg1);
cobj->hasOffScreenAttachments = arg1;
}
unsigned int arg2 = 0;
json->getProperty("framebufferID", &field);
if(!field.isUndefined()) {
ok &= seval_to_uint32(field, (uint32_t*)&arg2);
cobj->framebufferID = arg2;
}
if(!ok) {
JSB_FREE(cobj);
SE_REPORT_ERROR("argument convertion error");
return false;
}
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
else
{
cc::pipeline::RenderWindow* cobj = JSB_ALLOC(cc::pipeline::RenderWindow);
if (argc > 0 && !args[0].isUndefined()) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
cobj->hasOnScreenAttachments = arg0;
}
if (argc > 1 && !args[1].isUndefined()) {
unsigned int arg1 = 0;
ok &= seval_to_uint32(args[1], (uint32_t*)&arg1);
cobj->hasOffScreenAttachments = arg1;
}
if (argc > 2 && !args[2].isUndefined()) {
unsigned int arg2 = 0;
ok &= seval_to_uint32(args[2], (uint32_t*)&arg2);
cobj->framebufferID = arg2;
}
if(!ok) {
JSB_FREE(cobj);
SE_REPORT_ERROR("Argument convertion error");
return false;
}
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
return false;
}
SE_BIND_CTOR(js_pipeline_RenderWindow_constructor, __jsb_cc_pipeline_RenderWindow_class, js_cc_pipeline_RenderWindow_finalize)
static bool js_cc_pipeline_RenderWindow_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::RenderWindow* cobj = (cc::pipeline::RenderWindow*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_RenderWindow_finalize)
bool js_register_pipeline_RenderWindow(se::Object* obj)
{
auto cls = se::Class::create("RenderWindow", obj, nullptr, _SE(js_pipeline_RenderWindow_constructor));
cls->defineProperty("hasOnScreenAttachments", _SE(js_pipeline_RenderWindow_get_hasOnScreenAttachments), _SE(js_pipeline_RenderWindow_set_hasOnScreenAttachments));
cls->defineProperty("hasOffScreenAttachments", _SE(js_pipeline_RenderWindow_get_hasOffScreenAttachments), _SE(js_pipeline_RenderWindow_set_hasOffScreenAttachments));
cls->defineProperty("framebufferID", _SE(js_pipeline_RenderWindow_get_framebufferID), _SE(js_pipeline_RenderWindow_set_framebufferID));
cls->defineFunction("getFramebuffer", _SE(js_pipeline_RenderWindow_getFramebuffer));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_RenderWindow_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::RenderWindow>(cls);
__jsb_cc_pipeline_RenderWindow_proto = cls->getProto();
__jsb_cc_pipeline_RenderWindow_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
se::Object* __jsb_cc_pipeline_InstancedBuffer_proto = nullptr;
se::Class* __jsb_cc_pipeline_InstancedBuffer_class = nullptr;
static bool js_pipeline_InstancedBuffer_destroy(se::State& s)
{
cc::pipeline::InstancedBuffer* cobj = (cc::pipeline::InstancedBuffer*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_InstancedBuffer_destroy : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->destroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_pipeline_InstancedBuffer_destroy)
static bool js_pipeline_InstancedBuffer_setDynamicOffset(se::State& s)
{
cc::pipeline::InstancedBuffer* cobj = (cc::pipeline::InstancedBuffer*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_pipeline_InstancedBuffer_setDynamicOffset : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 2) {
unsigned int arg0 = 0;
unsigned int arg1 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
ok &= seval_to_uint32(args[1], (uint32_t*)&arg1);
SE_PRECONDITION2(ok, false, "js_pipeline_InstancedBuffer_setDynamicOffset : Error processing arguments");
cobj->setDynamicOffset(arg0, arg1);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
return false;
}
SE_BIND_FUNC(js_pipeline_InstancedBuffer_setDynamicOffset)
static bool js_pipeline_InstancedBuffer_get(se::State& s)
{
CC_UNUSED bool ok = true;
const auto& args = s.args();
size_t argc = args.size();
do {
if (argc == 2) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
if (!ok) { ok = true; break; }
unsigned int arg1 = 0;
ok &= seval_to_uint32(args[1], (uint32_t*)&arg1);
if (!ok) { ok = true; break; }
cc::pipeline::InstancedBuffer* result = cc::pipeline::InstancedBuffer::get(arg0, arg1);
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_InstancedBuffer_get : Error processing arguments");
return true;
}
} while (false);
do {
if (argc == 1) {
unsigned int arg0 = 0;
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
if (!ok) { ok = true; break; }
cc::pipeline::InstancedBuffer* result = cc::pipeline::InstancedBuffer::get(arg0);
ok &= native_ptr_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_pipeline_InstancedBuffer_get : Error processing arguments");
return true;
}
} while (false);
SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
return false;
}
SE_BIND_FUNC(js_pipeline_InstancedBuffer_get)
SE_DECLARE_FINALIZE_FUNC(js_cc_pipeline_InstancedBuffer_finalize)
static bool js_pipeline_InstancedBuffer_constructor(se::State& s)
{
CC_UNUSED bool ok = true;
const auto& args = s.args();
const cc::pipeline::PassView* arg0 = nullptr;
ok &= seval_to_native_ptr(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_pipeline_InstancedBuffer_constructor : Error processing arguments");
cc::pipeline::InstancedBuffer* cobj = JSB_ALLOC(cc::pipeline::InstancedBuffer, arg0);
s.thisObject()->setPrivateData(cobj);
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
return true;
}
SE_BIND_CTOR(js_pipeline_InstancedBuffer_constructor, __jsb_cc_pipeline_InstancedBuffer_class, js_cc_pipeline_InstancedBuffer_finalize)
static bool js_cc_pipeline_InstancedBuffer_finalize(se::State& s)
{
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
{
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
cc::pipeline::InstancedBuffer* cobj = (cc::pipeline::InstancedBuffer*)s.nativeThisObject();
JSB_FREE(cobj);
}
return true;
}
SE_BIND_FINALIZE_FUNC(js_cc_pipeline_InstancedBuffer_finalize)
bool js_register_pipeline_InstancedBuffer(se::Object* obj)
{
auto cls = se::Class::create("InstancedBuffer", obj, nullptr, _SE(js_pipeline_InstancedBuffer_constructor));
cls->defineFunction("destroy", _SE(js_pipeline_InstancedBuffer_destroy));
cls->defineFunction("setDynamicOffset", _SE(js_pipeline_InstancedBuffer_setDynamicOffset));
cls->defineStaticFunction("get", _SE(js_pipeline_InstancedBuffer_get));
cls->defineFinalizeFunction(_SE(js_cc_pipeline_InstancedBuffer_finalize));
cls->install();
JSBClassType::registerClass<cc::pipeline::InstancedBuffer>(cls);
__jsb_cc_pipeline_InstancedBuffer_proto = cls->getProto();
__jsb_cc_pipeline_InstancedBuffer_class = cls;
se::ScriptEngine::getInstance()->clearException();
return true;
}
bool register_all_pipeline(se::Object* obj)
{
// Get the ns
se::Value nsVal;
if (!obj->getProperty("nr", &nsVal))
{
se::HandleObject jsobj(se::Object::createPlainObject());
nsVal.setObject(jsobj);
obj->setProperty("nr", nsVal);
}
se::Object* ns = nsVal.toObject();
js_register_pipeline_RenderQueueDesc(ns);
js_register_pipeline_RenderFlow(ns);
js_register_pipeline_RenderPipeline(ns);
js_register_pipeline_RenderStageInfo(ns);
js_register_pipeline_ForwardPipeline(ns);
js_register_pipeline_RenderView(ns);
js_register_pipeline_RenderPipelineInfo(ns);
js_register_pipeline_RenderStage(ns);
js_register_pipeline_ForwardStage(ns);
js_register_pipeline_ShadowStage(ns);
js_register_pipeline_RenderFlowInfo(ns);
js_register_pipeline_UIStage(ns);
js_register_pipeline_ForwardFlow(ns);
js_register_pipeline_InstancedBuffer(ns);
js_register_pipeline_RenderWindow(ns);
js_register_pipeline_UIFlow(ns);
js_register_pipeline_ShadowFlow(ns);
return true;
}