mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
3777 lines
122 KiB
C++
3777 lines
122 KiB
C++
// 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_RasterPassBuilder_showStatistics_get(self_) self_->getShowStatistics()
|
|
#define cc_render_RasterPassBuilder_showStatistics_set(self_, val_) self_->setShowStatistics(val_)
|
|
|
|
|
|
#define cc_render_SceneVisitor_pipelineSceneData_get(self_) self_->getPipelineSceneData()
|
|
|
|
|
|
#define cc_render_SceneTask_taskType_get(self_) self_->getTaskType()
|
|
|
|
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
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_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->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_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_setReadWriteBuffer(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)->setReadWriteBuffer((ccstd::string const &)*arg2,arg3);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Setter_setReadWriteBuffer)
|
|
|
|
static bool js_cc_render_Setter_setReadWriteTexture(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)->setReadWriteTexture((ccstd::string const &)*arg2,arg3);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Setter_setReadWriteTexture)
|
|
|
|
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_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("setBuffer", _SE(js_cc_render_Setter_setBuffer));
|
|
cls->defineFunction("setTexture", _SE(js_cc_render_Setter_setTexture));
|
|
cls->defineFunction("setReadWriteBuffer", _SE(js_cc_render_Setter_setReadWriteBuffer));
|
|
cls->defineFunction("setReadWriteTexture", _SE(js_cc_render_Setter_setReadWriteTexture));
|
|
cls->defineFunction("setSampler", _SE(js_cc_render_Setter_setSampler));
|
|
|
|
|
|
|
|
|
|
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_RasterQueueBuilder_class = nullptr;
|
|
se::Object* __jsb_cc_render_RasterQueueBuilder_proto = nullptr;
|
|
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RasterQueueBuilder)
|
|
|
|
static bool js_cc_render_RasterQueueBuilder_addSceneOfCamera__SWIG_0(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) NULL ;
|
|
cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
|
|
LightInfo arg3 ;
|
|
SceneFlags arg4 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterQueueBuilder>(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_RasterQueueBuilder_addScene__SWIG_0(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) NULL ;
|
|
ccstd::string *arg2 = 0 ;
|
|
SceneFlags arg3 ;
|
|
ccstd::string temp2 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterQueueBuilder>(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)->addScene((ccstd::string const &)*arg2,arg3);
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool js_cc_render_RasterQueueBuilder_addFullscreenQuad__SWIG_0(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) NULL ;
|
|
Material *arg2 = (Material *) NULL ;
|
|
uint32_t arg3 ;
|
|
SceneFlags arg4 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterQueueBuilder>(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_RasterQueueBuilder_addCameraQuad__SWIG_0(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) NULL ;
|
|
cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
|
|
Material *arg3 = (Material *) NULL ;
|
|
uint32_t arg4 ;
|
|
SceneFlags arg5 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterQueueBuilder>(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_RasterQueueBuilder_clearRenderTarget__SWIG_0(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) NULL ;
|
|
ccstd::string *arg2 = 0 ;
|
|
gfx::Color *arg3 = 0 ;
|
|
ccstd::string temp2 ;
|
|
gfx::Color temp3 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterQueueBuilder>(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_RasterQueueBuilder_setViewport(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) 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::RasterQueueBuilder>(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_RasterQueueBuilder_setViewport)
|
|
|
|
static bool js_cc_render_RasterQueueBuilder_addSceneOfCamera__SWIG_1(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) NULL ;
|
|
cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
|
|
LightInfo arg3 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterQueueBuilder>(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_RasterQueueBuilder_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_RasterQueueBuilder_addSceneOfCamera__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 2) {
|
|
ok = js_cc_render_RasterQueueBuilder_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_RasterQueueBuilder_addSceneOfCamera)
|
|
|
|
static bool js_cc_render_RasterQueueBuilder_addScene__SWIG_1(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) NULL ;
|
|
ccstd::string *arg2 = 0 ;
|
|
ccstd::string temp2 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterQueueBuilder>(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)->addScene((ccstd::string const &)*arg2);
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool js_cc_render_RasterQueueBuilder_addScene(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_RasterQueueBuilder_addScene__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 1) {
|
|
ok = js_cc_render_RasterQueueBuilder_addScene__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_RasterQueueBuilder_addScene)
|
|
|
|
static bool js_cc_render_RasterQueueBuilder_addFullscreenQuad__SWIG_1(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) NULL ;
|
|
Material *arg2 = (Material *) NULL ;
|
|
uint32_t arg3 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterQueueBuilder>(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_RasterQueueBuilder_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_RasterQueueBuilder_addFullscreenQuad__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 2) {
|
|
ok = js_cc_render_RasterQueueBuilder_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_RasterQueueBuilder_addFullscreenQuad)
|
|
|
|
static bool js_cc_render_RasterQueueBuilder_addCameraQuad__SWIG_1(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) NULL ;
|
|
cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
|
|
Material *arg3 = (Material *) NULL ;
|
|
uint32_t arg4 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterQueueBuilder>(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_RasterQueueBuilder_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_RasterQueueBuilder_addCameraQuad__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 3) {
|
|
ok = js_cc_render_RasterQueueBuilder_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_RasterQueueBuilder_addCameraQuad)
|
|
|
|
static bool js_cc_render_RasterQueueBuilder_clearRenderTarget__SWIG_1(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterQueueBuilder *arg1 = (cc::render::RasterQueueBuilder *) NULL ;
|
|
ccstd::string *arg2 = 0 ;
|
|
ccstd::string temp2 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterQueueBuilder>(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_RasterQueueBuilder_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_RasterQueueBuilder_clearRenderTarget__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 1) {
|
|
ok = js_cc_render_RasterQueueBuilder_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_RasterQueueBuilder_clearRenderTarget)
|
|
|
|
static bool js_delete_cc_render_RasterQueueBuilder(se::State& s)
|
|
{
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_delete_cc_render_RasterQueueBuilder)
|
|
|
|
bool js_register_cc_render_RasterQueueBuilder(se::Object* obj) {
|
|
auto* cls = se::Class::create("RasterQueueBuilder", 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_RasterQueueBuilder_setViewport));
|
|
cls->defineFunction("addSceneOfCamera", _SE(js_cc_render_RasterQueueBuilder_addSceneOfCamera));
|
|
cls->defineFunction("addScene", _SE(js_cc_render_RasterQueueBuilder_addScene));
|
|
cls->defineFunction("addFullscreenQuad", _SE(js_cc_render_RasterQueueBuilder_addFullscreenQuad));
|
|
cls->defineFunction("addCameraQuad", _SE(js_cc_render_RasterQueueBuilder_addCameraQuad));
|
|
cls->defineFunction("clearRenderTarget", _SE(js_cc_render_RasterQueueBuilder_clearRenderTarget));
|
|
|
|
|
|
|
|
|
|
cls->defineFinalizeFunction(_SE(js_delete_cc_render_RasterQueueBuilder));
|
|
|
|
|
|
cls->install();
|
|
JSBClassType::registerClass<cc::render::RasterQueueBuilder>(cls);
|
|
|
|
__jsb_cc_render_RasterQueueBuilder_proto = cls->getProto();
|
|
__jsb_cc_render_RasterQueueBuilder_class = cls;
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
|
|
se::Class* __jsb_cc_render_RasterPassBuilder_class = nullptr;
|
|
se::Object* __jsb_cc_render_RasterPassBuilder_proto = nullptr;
|
|
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RasterPassBuilder)
|
|
|
|
static bool js_cc_render_RasterPassBuilder_addRasterView(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::RasterPassBuilder *arg1 = (cc::render::RasterPassBuilder *) NULL ;
|
|
ccstd::string *arg2 = 0 ;
|
|
RasterView *arg3 = 0 ;
|
|
ccstd::string temp2 ;
|
|
RasterView 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::RasterPassBuilder>(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)->addRasterView((ccstd::string const &)*arg2,(RasterView const &)*arg3);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_RasterPassBuilder_addRasterView)
|
|
|
|
static bool js_cc_render_RasterPassBuilder_addComputeView(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::RasterPassBuilder *arg1 = (cc::render::RasterPassBuilder *) NULL ;
|
|
ccstd::string *arg2 = 0 ;
|
|
ComputeView *arg3 = 0 ;
|
|
ccstd::string temp2 ;
|
|
ComputeView 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::RasterPassBuilder>(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)->addComputeView((ccstd::string const &)*arg2,(ComputeView const &)*arg3);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_RasterPassBuilder_addComputeView)
|
|
|
|
static bool js_cc_render_RasterPassBuilder_addQueue__SWIG_0(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterPassBuilder *arg1 = (cc::render::RasterPassBuilder *) NULL ;
|
|
QueueHint arg2 ;
|
|
cc::render::RasterQueueBuilder *result = 0 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterPassBuilder>(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::RasterQueueBuilder *)(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());
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool js_cc_render_RasterPassBuilder_setViewport(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::RasterPassBuilder *arg1 = (cc::render::RasterPassBuilder *) 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::RasterPassBuilder>(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_RasterPassBuilder_setViewport)
|
|
|
|
static bool js_cc_render_RasterPassBuilder_setVersion(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::RasterPassBuilder *arg1 = (cc::render::RasterPassBuilder *) 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::RasterPassBuilder>(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_RasterPassBuilder_setVersion)
|
|
|
|
static bool js_cc_render_RasterPassBuilder_addQueue__SWIG_1(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::RasterPassBuilder *arg1 = (cc::render::RasterPassBuilder *) NULL ;
|
|
cc::render::RasterQueueBuilder *result = 0 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterPassBuilder>(s);
|
|
if (nullptr == arg1) return true;
|
|
result = (cc::render::RasterQueueBuilder *)(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());
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool js_cc_render_RasterPassBuilder_addQueue(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_RasterPassBuilder_addQueue__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 0) {
|
|
ok = js_cc_render_RasterPassBuilder_addQueue__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_RasterPassBuilder_addQueue)
|
|
|
|
static bool js_cc_render_RasterPassBuilder_showStatistics_set(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::RasterPassBuilder *arg1 = (cc::render::RasterPassBuilder *) NULL ;
|
|
bool arg2 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterPassBuilder>(s);
|
|
if (nullptr == arg1) return true;
|
|
|
|
ok &= sevalue_to_native(args[0], &arg2);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
cc_render_RasterPassBuilder_showStatistics_set(arg1,arg2);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_PROP_SET(js_cc_render_RasterPassBuilder_showStatistics_set)
|
|
|
|
static bool js_cc_render_RasterPassBuilder_showStatistics_get(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
cc::render::RasterPassBuilder *arg1 = (cc::render::RasterPassBuilder *) NULL ;
|
|
bool result;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::RasterPassBuilder>(s);
|
|
if (nullptr == arg1) return true;
|
|
result = (bool)cc_render_RasterPassBuilder_showStatistics_get(arg1);
|
|
|
|
ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_PROP_GET(js_cc_render_RasterPassBuilder_showStatistics_get)
|
|
|
|
static bool js_delete_cc_render_RasterPassBuilder(se::State& s)
|
|
{
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_delete_cc_render_RasterPassBuilder)
|
|
|
|
bool js_register_cc_render_RasterPassBuilder(se::Object* obj) {
|
|
auto* cls = se::Class::create("RasterPassBuilder", 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_RasterPassBuilder_showStatistics_get), _SE(js_cc_render_RasterPassBuilder_showStatistics_set));
|
|
|
|
cls->defineFunction("addRasterView", _SE(js_cc_render_RasterPassBuilder_addRasterView));
|
|
cls->defineFunction("addComputeView", _SE(js_cc_render_RasterPassBuilder_addComputeView));
|
|
cls->defineFunction("setViewport", _SE(js_cc_render_RasterPassBuilder_setViewport));
|
|
cls->defineFunction("setVersion", _SE(js_cc_render_RasterPassBuilder_setVersion));
|
|
cls->defineFunction("addQueue", _SE(js_cc_render_RasterPassBuilder_addQueue));
|
|
|
|
|
|
|
|
|
|
cls->defineFinalizeFunction(_SE(js_delete_cc_render_RasterPassBuilder));
|
|
|
|
|
|
cls->install();
|
|
JSBClassType::registerClass<cc::render::RasterPassBuilder>(cls);
|
|
|
|
__jsb_cc_render_RasterPassBuilder_proto = cls->getProto();
|
|
__jsb_cc_render_RasterPassBuilder_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(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::ComputeQueueBuilder *arg1 = (cc::render::ComputeQueueBuilder *) NULL ;
|
|
ccstd::string *arg2 = 0 ;
|
|
uint32_t arg3 ;
|
|
uint32_t arg4 ;
|
|
uint32_t arg5 ;
|
|
ccstd::string temp2 ;
|
|
|
|
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::ComputeQueueBuilder>(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)->addDispatch((ccstd::string const &)*arg2,arg3,arg4,arg5);
|
|
|
|
|
|
return true;
|
|
}
|
|
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_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_addComputeView(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 ;
|
|
ComputeView *arg3 = 0 ;
|
|
ccstd::string temp2 ;
|
|
ComputeView 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::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)->addComputeView((ccstd::string const &)*arg2,(ComputeView const &)*arg3);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addComputeView)
|
|
|
|
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();
|
|
cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ;
|
|
cc::render::ComputeQueueBuilder *result = 0 ;
|
|
|
|
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::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());
|
|
|
|
|
|
return true;
|
|
}
|
|
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("addComputeView", _SE(js_cc_render_ComputePassBuilder_addComputeView));
|
|
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_MovePassBuilder_class = nullptr;
|
|
se::Object* __jsb_cc_render_MovePassBuilder_proto = nullptr;
|
|
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_MovePassBuilder)
|
|
|
|
static bool js_cc_render_MovePassBuilder_addPair(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::MovePassBuilder *arg1 = (cc::render::MovePassBuilder *) NULL ;
|
|
MovePair *arg2 = 0 ;
|
|
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::MovePassBuilder>(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)->addPair((MovePair const &)*arg2);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_MovePassBuilder_addPair)
|
|
|
|
static bool js_delete_cc_render_MovePassBuilder(se::State& s)
|
|
{
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_delete_cc_render_MovePassBuilder)
|
|
|
|
bool js_register_cc_render_MovePassBuilder(se::Object* obj) {
|
|
auto* cls = se::Class::create("MovePassBuilder", 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("addPair", _SE(js_cc_render_MovePassBuilder_addPair));
|
|
|
|
|
|
|
|
|
|
cls->defineFinalizeFunction(_SE(js_delete_cc_render_MovePassBuilder));
|
|
|
|
|
|
cls->install();
|
|
JSBClassType::registerClass<cc::render::MovePassBuilder>(cls);
|
|
|
|
__jsb_cc_render_MovePassBuilder_proto = cls->getProto();
|
|
__jsb_cc_render_MovePassBuilder_class = cls;
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
|
|
se::Class* __jsb_cc_render_CopyPassBuilder_class = nullptr;
|
|
se::Object* __jsb_cc_render_CopyPassBuilder_proto = nullptr;
|
|
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_CopyPassBuilder)
|
|
|
|
static bool js_cc_render_CopyPassBuilder_addPair(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::CopyPassBuilder *arg1 = (cc::render::CopyPassBuilder *) NULL ;
|
|
CopyPair *arg2 = 0 ;
|
|
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::CopyPassBuilder>(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)->addPair((CopyPair const &)*arg2);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_CopyPassBuilder_addPair)
|
|
|
|
static bool js_delete_cc_render_CopyPassBuilder(se::State& s)
|
|
{
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_delete_cc_render_CopyPassBuilder)
|
|
|
|
bool js_register_cc_render_CopyPassBuilder(se::Object* obj) {
|
|
auto* cls = se::Class::create("CopyPassBuilder", 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("addPair", _SE(js_cc_render_CopyPassBuilder_addPair));
|
|
|
|
|
|
|
|
|
|
cls->defineFinalizeFunction(_SE(js_delete_cc_render_CopyPassBuilder));
|
|
|
|
|
|
cls->install();
|
|
JSBClassType::registerClass<cc::render::CopyPassBuilder>(cls);
|
|
|
|
__jsb_cc_render_CopyPassBuilder_proto = cls->getProto();
|
|
__jsb_cc_render_CopyPassBuilder_class = cls;
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
|
|
se::Class* __jsb_cc_render_SceneVisitor_class = nullptr;
|
|
se::Object* __jsb_cc_render_SceneVisitor_proto = nullptr;
|
|
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_SceneVisitor)
|
|
|
|
static bool js_delete_cc_render_SceneVisitor(se::State& s)
|
|
{
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_delete_cc_render_SceneVisitor)
|
|
|
|
static bool js_cc_render_SceneVisitor_setViewport(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::SceneVisitor *arg1 = (cc::render::SceneVisitor *) 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::SceneVisitor>(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_SceneVisitor_setViewport)
|
|
|
|
static bool js_cc_render_SceneVisitor_setScissor(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::SceneVisitor *arg1 = (cc::render::SceneVisitor *) NULL ;
|
|
gfx::Rect *arg2 = 0 ;
|
|
gfx::Rect 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::SceneVisitor>(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)->setScissor((gfx::Rect const &)*arg2);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_SceneVisitor_setScissor)
|
|
|
|
static bool js_cc_render_SceneVisitor_bindPipelineState(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::SceneVisitor *arg1 = (cc::render::SceneVisitor *) NULL ;
|
|
gfx::PipelineState *arg2 = (gfx::PipelineState *) 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::SceneVisitor>(s);
|
|
if (nullptr == arg1) return true;
|
|
|
|
ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
(arg1)->bindPipelineState(arg2);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_SceneVisitor_bindPipelineState)
|
|
|
|
static bool js_cc_render_SceneVisitor_bindInputAssembler(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::SceneVisitor *arg1 = (cc::render::SceneVisitor *) NULL ;
|
|
gfx::InputAssembler *arg2 = (gfx::InputAssembler *) 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::SceneVisitor>(s);
|
|
if (nullptr == arg1) return true;
|
|
|
|
ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
(arg1)->bindInputAssembler(arg2);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_SceneVisitor_bindInputAssembler)
|
|
|
|
static bool js_cc_render_SceneVisitor_draw(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::SceneVisitor *arg1 = (cc::render::SceneVisitor *) NULL ;
|
|
gfx::DrawInfo *arg2 = 0 ;
|
|
gfx::DrawInfo 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::SceneVisitor>(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)->draw((gfx::DrawInfo const &)*arg2);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_SceneVisitor_draw)
|
|
|
|
static bool js_cc_render_SceneVisitor_pipelineSceneData_get(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
cc::render::SceneVisitor *arg1 = (cc::render::SceneVisitor *) NULL ;
|
|
cc::pipeline::PipelineSceneData *result = 0 ;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::SceneVisitor>(s);
|
|
if (nullptr == arg1) return true;
|
|
result = (cc::pipeline::PipelineSceneData *)cc_render_SceneVisitor_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_SceneVisitor_pipelineSceneData_get)
|
|
|
|
bool js_register_cc_render_SceneVisitor(se::Object* obj) {
|
|
auto* cls = se::Class::create("SceneVisitor", obj, nullptr, nullptr);
|
|
|
|
cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
|
|
cls->defineProperty("pipelineSceneData", _SE(js_cc_render_SceneVisitor_pipelineSceneData_get), nullptr);
|
|
|
|
cls->defineFunction("setViewport", _SE(js_cc_render_SceneVisitor_setViewport));
|
|
cls->defineFunction("setScissor", _SE(js_cc_render_SceneVisitor_setScissor));
|
|
cls->defineFunction("bindPipelineState", _SE(js_cc_render_SceneVisitor_bindPipelineState));
|
|
cls->defineFunction("bindInputAssembler", _SE(js_cc_render_SceneVisitor_bindInputAssembler));
|
|
cls->defineFunction("draw", _SE(js_cc_render_SceneVisitor_draw));
|
|
|
|
|
|
|
|
|
|
cls->defineFinalizeFunction(_SE(js_delete_cc_render_SceneVisitor));
|
|
|
|
|
|
cls->install();
|
|
JSBClassType::registerClass<cc::render::SceneVisitor>(cls);
|
|
|
|
__jsb_cc_render_SceneVisitor_proto = cls->getProto();
|
|
__jsb_cc_render_SceneVisitor_class = cls;
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
|
|
se::Class* __jsb_cc_render_SceneTask_class = nullptr;
|
|
se::Object* __jsb_cc_render_SceneTask_proto = nullptr;
|
|
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_SceneTask)
|
|
|
|
static bool js_delete_cc_render_SceneTask(se::State& s)
|
|
{
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_delete_cc_render_SceneTask)
|
|
|
|
static bool js_cc_render_SceneTask_start(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::SceneTask *arg1 = (cc::render::SceneTask *) 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::SceneTask>(s);
|
|
if (nullptr == arg1) return true;
|
|
(arg1)->start();
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_SceneTask_start)
|
|
|
|
static bool js_cc_render_SceneTask_join(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::SceneTask *arg1 = (cc::render::SceneTask *) 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::SceneTask>(s);
|
|
if (nullptr == arg1) return true;
|
|
(arg1)->join();
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_SceneTask_join)
|
|
|
|
static bool js_cc_render_SceneTask_submit(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::SceneTask *arg1 = (cc::render::SceneTask *) 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::SceneTask>(s);
|
|
if (nullptr == arg1) return true;
|
|
(arg1)->submit();
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_SceneTask_submit)
|
|
|
|
static bool js_cc_render_SceneTask_taskType_get(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
cc::render::SceneTask *arg1 = (cc::render::SceneTask *) NULL ;
|
|
cc::render::TaskType result;
|
|
|
|
arg1 = SE_THIS_OBJECT<cc::render::SceneTask>(s);
|
|
if (nullptr == arg1) return true;
|
|
result = cc_render_SceneTask_taskType_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_SceneTask_taskType_get)
|
|
|
|
bool js_register_cc_render_SceneTask(se::Object* obj) {
|
|
auto* cls = se::Class::create("SceneTask", obj, nullptr, nullptr);
|
|
|
|
cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
|
|
cls->defineProperty("taskType", _SE(js_cc_render_SceneTask_taskType_get), nullptr);
|
|
|
|
cls->defineFunction("start", _SE(js_cc_render_SceneTask_start));
|
|
cls->defineFunction("join", _SE(js_cc_render_SceneTask_join));
|
|
cls->defineFunction("submit", _SE(js_cc_render_SceneTask_submit));
|
|
|
|
|
|
|
|
|
|
cls->defineFinalizeFunction(_SE(js_delete_cc_render_SceneTask));
|
|
|
|
|
|
cls->install();
|
|
JSBClassType::registerClass<cc::render::SceneTask>(cls);
|
|
|
|
__jsb_cc_render_SceneTask_proto = cls->getProto();
|
|
__jsb_cc_render_SceneTask_class = cls;
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
|
|
se::Class* __jsb_cc_render_SceneTransversal_class = nullptr;
|
|
se::Object* __jsb_cc_render_SceneTransversal_proto = nullptr;
|
|
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_SceneTransversal)
|
|
|
|
static bool js_delete_cc_render_SceneTransversal(se::State& s)
|
|
{
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_delete_cc_render_SceneTransversal)
|
|
|
|
static bool js_cc_render_SceneTransversal_transverse(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
cc::render::SceneTransversal *arg1 = (cc::render::SceneTransversal *) NULL ;
|
|
cc::render::SceneVisitor *arg2 = (cc::render::SceneVisitor *) NULL ;
|
|
cc::render::SceneTask *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::SceneTransversal>(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::SceneTask *)((cc::render::SceneTransversal const *)arg1)->transverse(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_SceneTransversal_transverse)
|
|
|
|
bool js_register_cc_render_SceneTransversal(se::Object* obj) {
|
|
auto* cls = se::Class::create("SceneTransversal", obj, nullptr, nullptr);
|
|
|
|
cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
|
|
|
|
cls->defineFunction("transverse", _SE(js_cc_render_SceneTransversal_transverse));
|
|
|
|
|
|
|
|
|
|
cls->defineFinalizeFunction(_SE(js_delete_cc_render_SceneTransversal));
|
|
|
|
|
|
cls->install();
|
|
JSBClassType::registerClass<cc::render::SceneTransversal>(cls);
|
|
|
|
__jsb_cc_render_SceneTransversal_proto = cls->getProto();
|
|
__jsb_cc_render_SceneTransversal_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_beginSetup(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 ;
|
|
|
|
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::Pipeline>(s);
|
|
if (nullptr == arg1) return true;
|
|
(arg1)->beginSetup();
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Pipeline_beginSetup)
|
|
|
|
static bool js_cc_render_Pipeline_endSetup(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 ;
|
|
|
|
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::Pipeline>(s);
|
|
if (nullptr == arg1) return true;
|
|
(arg1)->endSetup();
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Pipeline_endSetup)
|
|
|
|
static bool js_cc_render_Pipeline_containsResource(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 ;
|
|
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::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 = (bool)((cc::render::Pipeline const *)arg1)->containsResource((ccstd::string const &)*arg2);
|
|
|
|
ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Pipeline_containsResource)
|
|
|
|
static bool js_cc_render_Pipeline_addRenderTexture(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::Format arg3 ;
|
|
uint32_t arg4 ;
|
|
uint32_t arg5 ;
|
|
cc::scene::RenderWindow *arg6 = (cc::scene::RenderWindow *) NULL ;
|
|
ccstd::string temp2 ;
|
|
uint32_t result;
|
|
|
|
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], &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)->addRenderTexture((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6);
|
|
|
|
ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Pipeline_addRenderTexture)
|
|
|
|
static bool js_cc_render_Pipeline_addRenderTarget__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)->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_Pipeline_addDepthStencil__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)->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_Pipeline_updateRenderWindow(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 ;
|
|
cc::scene::RenderWindow *arg3 = (cc::scene::RenderWindow *) 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::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)->updateRenderWindow((ccstd::string const &)*arg2,arg3);
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Pipeline_updateRenderWindow)
|
|
|
|
static bool js_cc_render_Pipeline_updateRenderTarget__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)->updateRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5);
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool js_cc_render_Pipeline_updateDepthStencil__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)->updateDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5);
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool js_cc_render_Pipeline_beginFrame(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 ;
|
|
|
|
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::Pipeline>(s);
|
|
if (nullptr == arg1) return true;
|
|
(arg1)->beginFrame();
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Pipeline_beginFrame)
|
|
|
|
static bool js_cc_render_Pipeline_endFrame(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 ;
|
|
|
|
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::Pipeline>(s);
|
|
if (nullptr == arg1) return true;
|
|
(arg1)->endFrame();
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Pipeline_endFrame)
|
|
|
|
static bool js_cc_render_Pipeline_addRasterPass__SWIG_0(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
|
|
uint32_t arg2 ;
|
|
uint32_t arg3 ;
|
|
ccstd::string *arg4 = 0 ;
|
|
ccstd::string temp4 ;
|
|
cc::render::RasterPassBuilder *result = 0 ;
|
|
|
|
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::RasterPassBuilder *)(arg1)->addRasterPass(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());
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
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());
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Pipeline_addComputePass)
|
|
|
|
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 ;
|
|
cc::render::MovePassBuilder *result = 0 ;
|
|
|
|
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::Pipeline>(s);
|
|
if (nullptr == arg1) return true;
|
|
result = (cc::render::MovePassBuilder *)(arg1)->addMovePass();
|
|
|
|
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_Pipeline_addMovePass)
|
|
|
|
static bool js_cc_render_Pipeline_addCopyPass(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 ;
|
|
cc::render::CopyPassBuilder *result = 0 ;
|
|
|
|
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::Pipeline>(s);
|
|
if (nullptr == arg1) return true;
|
|
result = (cc::render::CopyPassBuilder *)(arg1)->addCopyPass();
|
|
|
|
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_Pipeline_addCopyPass)
|
|
|
|
static bool js_cc_render_Pipeline_presentAll(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 ;
|
|
|
|
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::Pipeline>(s);
|
|
if (nullptr == arg1) return true;
|
|
(arg1)->presentAll();
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Pipeline_presentAll)
|
|
|
|
static bool js_cc_render_Pipeline_createSceneTransversal(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 ;
|
|
cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ;
|
|
cc::scene::RenderScene *arg3 = (cc::scene::RenderScene *) NULL ;
|
|
cc::render::SceneTransversal *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::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");
|
|
result = (cc::render::SceneTransversal *)(arg1)->createSceneTransversal((cc::scene::Camera const *)arg2,(cc::scene::RenderScene 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());
|
|
|
|
|
|
return true;
|
|
}
|
|
SE_BIND_FUNC(js_cc_render_Pipeline_createSceneTransversal)
|
|
|
|
static bool js_cc_render_Pipeline_getDescriptorSetLayout(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 ;
|
|
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::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");
|
|
|
|
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_Pipeline_getDescriptorSetLayout)
|
|
|
|
static bool js_cc_render_Pipeline_addRenderTarget__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)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5);
|
|
|
|
ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool js_cc_render_Pipeline_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_Pipeline_addRenderTarget__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 4) {
|
|
ok = js_cc_render_Pipeline_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_Pipeline_addRenderTarget)
|
|
|
|
static bool js_cc_render_Pipeline_addDepthStencil__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)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5);
|
|
|
|
ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool js_cc_render_Pipeline_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_Pipeline_addDepthStencil__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 4) {
|
|
ok = js_cc_render_Pipeline_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_Pipeline_addDepthStencil)
|
|
|
|
static bool js_cc_render_Pipeline_updateRenderTarget__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)->updateRenderTarget((ccstd::string const &)*arg2,arg3,arg4);
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool js_cc_render_Pipeline_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_Pipeline_updateRenderTarget__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 3) {
|
|
ok = js_cc_render_Pipeline_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_Pipeline_updateRenderTarget)
|
|
|
|
static bool js_cc_render_Pipeline_updateDepthStencil__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)->updateDepthStencil((ccstd::string const &)*arg2,arg3,arg4);
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool js_cc_render_Pipeline_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_Pipeline_updateDepthStencil__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 3) {
|
|
ok = js_cc_render_Pipeline_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_Pipeline_updateDepthStencil)
|
|
|
|
static bool js_cc_render_Pipeline_addRasterPass__SWIG_1(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
const auto& args = s.args();
|
|
cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ;
|
|
uint32_t arg2 ;
|
|
uint32_t arg3 ;
|
|
cc::render::RasterPassBuilder *result = 0 ;
|
|
|
|
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");
|
|
|
|
result = (cc::render::RasterPassBuilder *)(arg1)->addRasterPass(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;
|
|
}
|
|
|
|
static bool js_cc_render_Pipeline_addRasterPass(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_addRasterPass__SWIG_0(s);
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
}
|
|
if (argc == 2) {
|
|
ok = js_cc_render_Pipeline_addRasterPass__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_addRasterPass)
|
|
|
|
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_PipelineRuntime_proto, nullptr);
|
|
|
|
cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
|
|
|
|
cls->defineFunction("beginSetup", _SE(js_cc_render_Pipeline_beginSetup));
|
|
cls->defineFunction("endSetup", _SE(js_cc_render_Pipeline_endSetup));
|
|
cls->defineFunction("containsResource", _SE(js_cc_render_Pipeline_containsResource));
|
|
cls->defineFunction("addRenderTexture", _SE(js_cc_render_Pipeline_addRenderTexture));
|
|
cls->defineFunction("updateRenderWindow", _SE(js_cc_render_Pipeline_updateRenderWindow));
|
|
cls->defineFunction("beginFrame", _SE(js_cc_render_Pipeline_beginFrame));
|
|
cls->defineFunction("endFrame", _SE(js_cc_render_Pipeline_endFrame));
|
|
cls->defineFunction("addComputePass", _SE(js_cc_render_Pipeline_addComputePass));
|
|
cls->defineFunction("addMovePass", _SE(js_cc_render_Pipeline_addMovePass));
|
|
cls->defineFunction("addCopyPass", _SE(js_cc_render_Pipeline_addCopyPass));
|
|
cls->defineFunction("presentAll", _SE(js_cc_render_Pipeline_presentAll));
|
|
cls->defineFunction("createSceneTransversal", _SE(js_cc_render_Pipeline_createSceneTransversal));
|
|
cls->defineFunction("getDescriptorSetLayout", _SE(js_cc_render_Pipeline_getDescriptorSetLayout));
|
|
cls->defineFunction("addRenderTarget", _SE(js_cc_render_Pipeline_addRenderTarget));
|
|
cls->defineFunction("addDepthStencil", _SE(js_cc_render_Pipeline_addDepthStencil));
|
|
cls->defineFunction("updateRenderTarget", _SE(js_cc_render_Pipeline_updateRenderTarget));
|
|
cls->defineFunction("updateDepthStencil", _SE(js_cc_render_Pipeline_updateDepthStencil));
|
|
cls->defineFunction("addRasterPass", _SE(js_cc_render_Pipeline_addRasterPass));
|
|
|
|
|
|
|
|
|
|
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_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_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::Pipeline *arg3 = (cc::render::Pipeline *) 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)
|
|
|
|
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("setup", _SE(js_cc_render_PipelineBuilder_setup));
|
|
|
|
|
|
|
|
|
|
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_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("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_RenderNode(ns);
|
|
js_register_cc_render_Setter(ns);
|
|
js_register_cc_render_RasterQueueBuilder(ns);
|
|
js_register_cc_render_RasterPassBuilder(ns);
|
|
js_register_cc_render_ComputeQueueBuilder(ns);
|
|
js_register_cc_render_ComputePassBuilder(ns);
|
|
js_register_cc_render_MovePassBuilder(ns);
|
|
js_register_cc_render_CopyPassBuilder(ns);
|
|
js_register_cc_render_SceneVisitor(ns);
|
|
js_register_cc_render_SceneTask(ns);
|
|
js_register_cc_render_SceneTransversal(ns);
|
|
js_register_cc_render_Pipeline(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
|